Introdução à classificação em C

No aplicativo, os desenvolvedores sentem o desejo de classificar os dados para permitir a funcionalidade específica. Existem várias abordagens para classificar os dados e eles são contados na classificação de acordo com a nomenclatura. A classificação pode ser definida como o método de organizar os dados de uma maneira específica que segue alguma ordem. Aqui nesta seção, vamos aprender sobre a classificação usando a linguagem de programação C. Existem vários tipos de classificação, como a classificação de bolhas, classificação de mesclagem, classificação de seleção, classificação de inserção e assim por diante. Faremos a codificação real para os métodos de classificação que são usados ​​com muita frequência no aplicativo. Os códigos estarão disponíveis para você em formato textual, para que você possa achar fácil usá-lo enquanto a saída será exibida na captura de tela para fornecer uma visão geral da saída real após a execução do programa.

Como a classificação é realizada em C?

  • A classificação pode ser realizada de várias maneiras, com base no algoritmo de classificação. Na linguagem de programação C, temos várias abordagens para classificar a lista. O termo classificação indica a organização dos dados de uma maneira específica, geralmente em ordem crescente. Embora a maneira de classificar os dados seja diferente em todos os algoritmos de classificação, o resultado de todos eles é o mesmo.
  • Normalmente, na classificação, o programa procura o número mínimo e o desloca para o início da lista e repete as mesmas pesquisas. Novamente, uma vez encontrado o outro número pequeno, ele é deslocado para o próximo espaço na lista logo após o primeiro índice e esse processo continua repetindo até que a lista de classificação seja obtida. É assim que a classificação é feita na linguagem de programação C.
  • Em todas as abordagens para classificar a lista, o array desempenha um papel muito importante na linguagem de programação C. Em todo algoritmo, a matriz foi usada para armazenar a lista dos elementos que precisam ser classificados. Por exemplo, na classificação por bolhas, os elementos são armazenados na matriz única e os valores na matriz foram processados ​​para convertê-los em uma lista de dados classificados.
  • Na classificação de seleção, a mesma matriz foi tratada como duas matrizes em que a primeira matriz é considerada vazia, a fim de informar os valores classificados, enquanto a segunda matriz mantém a lista não classificada. Para servir ao propósito de classificar, a matriz é usada com muita frequência em vez de conter os valores em variáveis ​​individuais. Entre todos os algoritmos, a classificação rápida funciona muito rapidamente e, portanto, denominada classificação rápida. Demora muito menos tempo em comparação com outros algoritmos de classificação.

Tipos de classificação em C

1. Classificação por bolhas

  • A classificação por bolha pode ser definida como o algoritmo de classificação que segue a abordagem de substituir o valor no primeiro índice pelo menor valor na matriz e mantê-lo repetindo até que a lista seja classificada. É uma maneira muito simples de realizar a classificação. Dessa maneira, para classificar a matriz, o valor deve ser atribuído à matriz no início antes de iniciar a classificação.
  • Abaixo está o programa para classificar a matriz usando a classificação por bolhas onde os valores foram obtidos do usuário. Depois que o programa é compilado e executado, ele solicita ao usuário o número de elementos que deseja classificar. Depois que o número for fornecido, o programa solicitará que o usuário forneça valores equivalentes à contagem que eles forneceram. Os valores serão armazenados na matriz e serão processados ​​ainda mais usando o loop aninhado, juntamente com a tomada de decisão usando "se" para classificar a matriz.
  • O primeiro menor valor encontrado na matriz foi movido para o primeiro índice da matriz e, em seguida, a pesquisa começa novamente para encontrar o outro menor número. Quando o próximo número menor é encontrado, ele substitui o valor no segundo índice e o processo continua repetindo até que a matriz consista em uma lista classificada de valores.

Código

#include
int main()
(
int total_count, counter, counter1, swap_var;
int array(20);
printf("How many number you want to input?\n");
scanf("%d", &total_count);
printf("Please enter %d integers that has to be sorted\n", total_count);
for (counter = 0; counter < total_count; counter++)
scanf("%d", &array(counter));
for (counter = 0 ; counter < total_count - 1; counter++)
(
for (counter1 = 0 ; counter1 < total_count - counter - 1; counter1++)
(
if (array(counter1) > array(counter1+1)) /* For decreasing order use < */
(
swap_var = array(counter1);
array(counter1) = array(counter1+1);
array(counter1+1) = swap_var;
)
)
)
printf("Below is the list of elements sorted in ascending order:\n");
for (counter = 0; counter < total_count; counter++)
printf("%d\n", array(counter));
return 0;
)

O usuário enviou a entrada 5 3 60 14 1 2 645. O algoritmo foi aplicado à matriz que consiste em valores da maneira como é fornecida pelo usuário e, após o processamento, a saída que recebemos é 1 2 3 5 14 60 645 .

Resultado:

2. Seleção da Seleção

  • A classificação de seleção pode ser definida como outro algoritmo para classificar a lista na qual a matriz é bifurcada em duas matrizes, onde a primeira matriz deve estar vazia enquanto a segunda matriz consiste em uma lista não classificada de valores. O programa procura os menores valores na segunda matriz e, quando o valor é encontrado, foi movido para o início da primeira matriz que estava vazia. A abordagem é repetida novamente e os próximos valores menores serão deslocados para o segundo índice da primeira matriz. Os processos continuarão se repetindo até a segunda matriz ficar vazia.
  • O programa abaixo é a implementação de codificação do algoritmo de classificação de seleção. Depois que o programa for executado com êxito, ele solicitará que o usuário insira a contagem de valores que deseja classificar. Uma vez obtida a contagem, o programa solicitará que o usuário insira os valores para a matriz que deve ser classificada. O valor é então processado usando o loop aninhado para classificar os números. A verificação da condição if também foi envolvida aqui para verificar o menor número.
  • Os processos serão repetidos até que a primeira lista esteja cheia da lista classificada. Enquanto isso, os programas mantêm seu foco principal para verificar se o segundo array está tendo valor e se for encontrado positivo, o programa executa o algoritmo de classificação novamente. Embora classifique a lista de maneira fácil, pode demorar um pouco mais em comparação com os outros algoritmos. Mas, no final, o resultado que ele gerará será o mesmo que os outros algoritmos de classificação.

Código
#include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
) #include
#include
void main()
(
int total_count, counter1, counter2, minimum, temp_value;
int a(20);
printf("\n Enter the Number of Elements: ");
scanf("%d", &total_count);
printf("\n Enter %d Elements: ", total_count);
for(counter1=0;counter1 (
scanf("%d", &a(counter1));
)
for(counter1=0;counter1 (
minimum=counter1;
for(counter2=counter1+1;counter2 (
if(a(minimum)>a(counter2))
minimum=counter2;
)
if(minimum!=counter1)
(
temp_value=a(counter1);
a(counter1)=a(minimum);
a(minimum)=temp_value;
)
)
printf("\n The Sorted array in ascending order: ");
for(counter1=0;counter1 (
printf("%d ", a(counter1));
)
getch();
)

Ao solicitar a contagem de elementos que precisam ser classificados, o usuário forneceu 6 na saída abaixo. Posteriormente, os valores introduzidos são 25 65 36 86 96 45. Esses valores são armazenados na matriz que se espera que seja bifurcada em duas matrizes, onde uma ficará vazia para armazenar a lista classificada e a outra terá a lista não classificada . Após o processamento da entrada, o resultado foi 25 36 45 65 86 96. Essa perda foi classificada usando a classificação de seleção. Depois que todos os seis valores tiverem sido movidos para a primeira matriz na forma classificada, a segunda matriz ficará vazia e o algoritmo será encerrado.

Resultado:

3. Classificação Rápida

  • O Quicksort pode ser definido como o outro algoritmo para classificar a lista na qual a abordagem é dividir a matriz em termos de valores maiores e menores que os valores até que os valores inteiros sejam divididos em formas individuais. Nesse algoritmo, o valor do último índice da matriz foi selecionado como um pivô e todos os valores menores que o pivô foram deslocados para a matriz que se espera ocorrer à esquerda do valor e os elementos com um valor mais alto que o pivô são deslocados para a matriz correta. Novamente, um pivô é selecionado na matriz recém-formada que tinha os valores menores que o último valor de pivô. Da mesma forma, os valores menores que o novo pivô serão deslocados para a matriz que será deixada e os valores maiores que o novo pivô serão alterados para a matriz direita.
  • O programa abaixo é a implementação do quicksort usando a linguagem de programação C. Depois que o programa for executado, ele solicitará ao usuário o número de elementos que deseja classificar. Com base na contagem, o loop for iterará os tempos estimados para receber a entrada do usuário. A entrada será processada usando as condições if junto com o loop for para gerar uma lista classificada. A matriz continuará organizando os valores usando o valor de pivô até que todos os valores tenham sido verificados quanto ao menor valor.
  • A classificação feita usando esse algoritmo é muito mais rápida em comparação com os outros algoritmos de classificação, e é por isso que foi chamada de classificação rápida. Quicksort é o único algoritmo que leva a dividir a matriz até que todos os valores sejam separados nas matrizes individuais. Eles serão adicionados ou agregados em uma única matriz que é considerada como a lista classificada.

Código:

#include
void quicksort_method (int (), int, int);
int main()
(
int element_list(50), count, counter;
printf("Please enter the total count of the elements that you want to sort: ");
scanf("%d", &count);
printf("Please input the elements that has to be sorted:\n");
for (counter = 0; counter < count; counter++)
(
scanf("%d", &element_list(counter));
)
quicksort_method(element_list, 0, count - 1);
printf("Output generated after using quick sort\n");
for (counter = 0; counter < count; counter++)
(
printf("%d ", element_list(counter));
)
printf("\n");
return 0;
)
void quicksort_method(int element_list(), int low, int high)
(
int pivot, value1, value2, temp;
if (low < high)
(
pivot = low;
value1 = low;
value2 = high;
while (value1 < value2)
(
while (element_list(value1) <= element_list(pivot) && value1 <= high)
(
value1++;
)
while (element_list(value2) > element_list(pivot) && value2 >= low)
(
value2--;
)
if (value1 < value2)
(
temp = element_list(value1);
element_list(value1) = element_list(value2);
element_list(value2) = temp;
)
)
temp = element_list(value2);
element_list(value2) = element_list(pivot);
element_list(pivot) = temp;
quicksort_method(element_list, low, value2 - 1);
quicksort_method(element_list, value2 + 1, high);
)
)

Na saída abaixo, o usuário confirmou que enviará 6 valores e formará uma lista de dados classificados. Após fornecer a contagem, os valores fornecidos pelo usuário são 56, 35, 24, 86, 98, 2. A classificação rápida foi aplicada a esses valores e a lista classificada foi gerada com o valor 2, 24, 35, 56 86, 98.

Resultado:

4. Mesclar Classificação

  • A classificação de mesclagem pode ser definida como outro algoritmo de classificação que realiza a classificação segregando a matriz até o último quando se transforma em um valor individual e, em seguida, agregando-as de uma maneira que possa se transformar em uma matriz classificada.
  • O processo consome um pouco de tempo em comparação com outros algoritmos rivais, mas é considerado bastante eficiente em comparação com outros. Quando se trata de classificar uma lista grande, esse algoritmo funciona muito bem e, portanto, é preferido no desenvolvimento do aplicativo que precisa processar a lista grande.

Código:

#include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
) #include
void algo_merge_sort(int val(), int counter1, int counter2);
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21);
int main()
(
int val(100), chk, counter1;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 scanf("%d", &val(counter1));
algo_merge_sort(val, 0, chk-1);
printf("\n Output generated after using quick sort \n");
for(counter1=0;counter1 printf("%d ", val(counter1));
return 0;
)
void algo_merge_sort(int val(), int counter1, int counter2)
(
int mid;
if(counter1 (
mid=(counter1+counter2)/2;
algo_merge_sort(val, counter1, mid);
algo_merge_sort(val, mid+1, counter2);
perfrom_merge(val, counter1, mid, mid+1, counter2);
)
)
void perfrom_merge(int val(), int counter11, int counter12, int counter22, int counter21)
(
int temp_val(50);
int c1, c2, c3;
c1=counter11;
c2=counter22;
c3=0;
while(c1<=counter12 && c2<=counter21)
(
if(val(c1) temp_val(c3++)=val(c1++);
else
temp_val(c3++)=val(c2++);
)
while(c1<=counter12)
temp_val(c3++)=val(c1++);
while(c2<=counter21)
temp_val(c3++)=val(c2++);
for(c1=counter11, c2=0;c1<=counter21;c1++, c2++)
val(c1)=temp_val(c2);
)
Quando o código acima é executado, ele primeiro pede ao usuário que forneça o número de elementos que deseja classificar. Depois que o número for enviado, eles precisarão fornecer os valores de contagem igual que eles forneceram inicialmente. Depois que os valores forem enviados, o algoritmo manterá esses valores na matriz e o processará para transformar a matriz na matriz classificada. Depois que a matriz é classificada em ordem crescente, a saída será exibida para o usuário.

Resultado:

5. Heapsort

  • A classificação de heap pode ser definida como o algoritmo de classificação que funciona pesquisando o elemento máximo na lista e colocando-o no último. O algoritmo executa a ação recursivamente até que a matriz seja classificada da maneira ascendente.
  • É muito demorado o processo para escolher o valor máximo e movê-lo para o último e, portanto, é considerado uma abordagem de classificação menos eficiente quando se trata de classificar a lista grande. No entanto, ele funciona bem com a lista que possui um número limitado de valores. Abaixo está a implementação desse algoritmo na linguagem de programação C, juntamente com a saída.

Código:

#include
void form(int ());
void set_down(int (), int);
int main()
(
int val(100), chk, counter, end, temp_val;
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter=1;counter<=chk;counter++)
scanf("%d", &val(counter));
val(0)=chk;
form(val);
while(val(0) > 1)
(
end=val(0);
temp_val=val(1);
val(1)=val(end);
val(end)=temp_val;
val(0)--;
set_down(val, 1);
)
printf("\n Output generated after using heap sort \n");
for(counter=1;counter<=chk;counter++)
printf("%d ", val(counter));
)
void form(int val())
(
int counter, chk;
chk=val(0);
for(counter=chk/2;counter>=1;counter--)
set_down(val, counter);
)
void set_down(int val(), int counter)
(
int counter2, temp_val, chk, flag=1;
chk=val(0);
while(2*counter<=chk && flag==1)
(
counter2=2*counter;
if(counter2+1 val(counter2))
counter2=counter2+1;
if(val(counter) > val(counter2))
flag=0;
else
(
temp_val=val(counter);
val(counter)=val(counter2);
val(counter2)=temp_val;
counter=counter2;
)
)
)
O funcionamento desse algoritmo é igual ao de outros algoritmos de classificação, pois também classifica a lista em ordem crescente. Quando o código escrito acima é executado, o usuário deve enviar a contagem de valores que eles serão classificados. Depois que os valores forem enviados, o código os processará para transformar a matriz na ordenada. A saída será mostrada eventualmente e pode-se observar que os valores que foram enviados pelo usuário foram classificados em ordem crescente.

Resultado:

6. Classificação de Inserção

  • A classificação por inserção pode ser definida como o algoritmo de classificação que funciona movendo o valor mínimo no início da lista, um de cada vez. Esse é um algoritmo de classificação muito menos eficiente e não é adequado para lidar com a grande lista.
  • Essa abordagem de classificação do algoritmo funciona muito lentamente e geralmente não é preferida em nenhum dos aplicativos. Pode funcionar bem com a lista que possui poucos números de elementos. Para os aplicativos, que têm o requisito de processar alguns números de valores, podem aproveitar esse algoritmo.

Código:

#include
int main()
(
int counter1, counter2, chk, temp_val, val(100);
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 (
scanf("%d", &val(counter1));
)
for(counter1=1;counter1<=chk-1;counter1++)
(
temp_val=val(counter1);
counter2=counter1-1;
while((temp_val=0))
(
val(counter2+1)=val(counter2);
counter2=counter2-1;
)
val(counter2+1)=temp_val;
)
printf("\n Output generated after using insertion sort \n");
for(counter1=0;counter1 (
printf("%d ", val(counter1));
)
return 0;
) #include
int main()
(
int counter1, counter2, chk, temp_val, val(100);
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 (
scanf("%d", &val(counter1));
)
for(counter1=1;counter1<=chk-1;counter1++)
(
temp_val=val(counter1);
counter2=counter1-1;
while((temp_val=0))
(
val(counter2+1)=val(counter2);
counter2=counter2-1;
)
val(counter2+1)=temp_val;
)
printf("\n Output generated after using insertion sort \n");
for(counter1=0;counter1 (
printf("%d ", val(counter1));
)
return 0;
) #include
int main()
(
int counter1, counter2, chk, temp_val, val(100);
printf("Please enter the total count of the elements that you want to sort: \n");
scanf("%d", &chk);
printf("Please input the elements that has to be sorted:\n");
for(counter1=0;counter1 (
scanf("%d", &val(counter1));
)
for(counter1=1;counter1<=chk-1;counter1++)
(
temp_val=val(counter1);
counter2=counter1-1;
while((temp_val=0))
(
val(counter2+1)=val(counter2);
counter2=counter2-1;
)
val(counter2+1)=temp_val;
)
printf("\n Output generated after using insertion sort \n");
for(counter1=0;counter1 (
printf("%d ", val(counter1));
)
return 0;
)

Quando o programa é executado, o usuário precisará inserir o número de valores que precisa classificar. Depois, os valores inseridos pelo usuário serão armazenados na matriz. Eles serão processados ​​e, pelo uso da verificação de loop e condição, o valor mínimo será movido para o início em cada recursão e terminará gerando uma matriz classificada. Os valores serão exibidos para o usuário no final do programa.

Resultado :

Conclusão

O algoritmo de classificação é usado para gerar uma lista classificada, que é uma lista normal em que todos os valores são classificados de uma maneira específica. A lista tem sido usada com muita frequência no aplicativo real para trazer algumas funcionalidades. Neste artigo, abordamos a classificação por bolha, a seleção e a classificação rápida, enquanto existem vários outros algoritmos, como a classificação por mesclagem, que podem ser aproveitados para gerar uma lista classificada. Entre todos os algoritmos de classificação, o quicksort funciona muito rápido e ajuda a classificar a lista muito rapidamente. Os programas escritos aqui são basicamente para implementar esses algoritmos de classificação usando a linguagem de programação C. Se você deseja implementar o mesmo em outras linguagens de programação, pode usar a mesma lógica e a única coisa que pode variar pode ser a sintaxe e as palavras-chave.

Artigo recomendado

Este foi um guia para Classificar em C. Aqui discutimos uma introdução em Classificando em C e diferentes tipos de classificação, juntamente com o código de exemplo. Você também pode consultar nossos outros artigos sugeridos para saber mais -

  1. Padrões em Programação C
  2. Palíndromo no programa C
  3. Mesclar classificação em Java
  4. Introdução à classificação em R
  5. Introdução à classificação em C ++
  6. Visão geral da classificação em PHP
  7. Heap Sort em Python
  8. Função de classificação em Python com exemplos

Categoria:

Desenvolvimento de software