Introducción a la clasificación en C
En la aplicación, los desarrolladores sienten la necesidad de ordenar los datos para permitirles brindar una funcionalidad particular. Hay varios enfoques para ordenar los datos y se cuentan bajo ordenación según la nomenclatura. La ordenación se puede definir como el método de organizar los datos de una manera particular que sigue un cierto orden. Aquí, en esta sección, aprenderemos sobre la clasificación utilizando el lenguaje de programación C. Existen varios tipos de ordenación, como la ordenación por burbuja, la ordenación por fusión, la ordenación por selección, la ordenación por inserción, etc. Haremos una codificación real para los métodos de clasificación que se usan con mucha frecuencia en la aplicación. Los códigos estarán disponibles para usted en un formato de texto para que le resulte fácil usar ese código mientras que la salida se mostrará en la captura de pantalla para darle una idea de la salida real que viene después de ejecutar el programa.
¿Cómo se realiza la clasificación en C?
- La clasificación se puede realizar de varias maneras según el algoritmo de clasificación. En el lenguaje de programación C tenemos varios enfoques para ordenar la lista. El término ordenación establece la disposición de los datos de una manera particular, generalmente en orden ascendente. Aunque la forma de ordenar los datos es diferente en todos los algoritmos de clasificación, el resultado de todos ellos es el mismo.
- Por lo general, al ordenar, el programa busca el número mínimo y cambia ese número al comienzo de la lista y repite las mismas búsquedas. Nuevamente, una vez que se encuentra el otro número pequeño, se desplaza al siguiente espacio de la lista justo después del primer índice y este proceso continúa repitiéndose hasta que se obtiene la lista de clasificación. Esta es la forma en que se realiza la clasificación en el lenguaje de programación C.
- En todos los enfoques para ordenar la lista, la matriz juega un papel muy vital en el lenguaje de programación C. En cada algoritmo, la matriz se ha utilizado para almacenar la lista de los elementos que deben clasificarse. Por ejemplo, en la clasificación de burbujas, los elementos se almacenan en la matriz única y los valores de la matriz se procesaron para convertirlos en una lista de datos ordenados.
- En el orden de selección, la misma matriz se ha tratado como dos matrices donde la primera matriz se considera vacante para indicar los valores ordenados mientras que la segunda matriz contiene la lista sin ordenar. Para servir el propósito de ordenar la matriz se usa muy a menudo en lugar de mantener los valores en variables individuales. Entre todos los algoritmos, la ordenación rápida funciona muy rápido y, por lo tanto, se denomina ordenación rápida. Lleva mucho menos tiempo en comparación con los otros algoritmos de clasificación.
Tipos de clasificación en C
1. Ordenar burbujas
- La clasificación de burbujas se puede definir como el algoritmo de clasificación que sigue el enfoque de reemplazar el valor en el primer índice con el valor más pequeño en la matriz y mantenerlo repitiendo hasta que se ordene la lista. Es una forma muy simple de realizar la clasificación. De esta forma, para ordenar la matriz, el valor debe asignarse a la matriz al principio antes de comenzar la clasificación.
- A continuación se muestra el programa para ordenar la matriz utilizando el método de burbuja donde los valores han sido tomados del usuario. Una vez que el programa se compila y ejecuta, le pedirá al usuario la cantidad de elementos que desea ordenar. Una vez que se proporciona el número, el programa le pedirá al usuario que proporcione valores equivalentes al recuento que ha proporcionado. Los valores se almacenarán en la matriz y se procesarán aún más utilizando el bucle anidado para junto con la toma de decisiones utilizando "if" para ordenar la matriz.
- El primer valor más pequeño encontrado en la matriz se ha movido al primer índice de la matriz y luego la búsqueda comienza nuevamente para encontrar el otro número más pequeño. Una vez que se encuentra el siguiente número más pequeño, reemplaza el valor en el segundo índice y el proceso continúa repitiéndose hasta que la matriz consiste en una lista ordenada 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;
)
El usuario ha enviado la entrada 5 3 60 14 1 2 645. El algoritmo se ha aplicado en la matriz que consta de valores en la forma en que lo proporciona el usuario y, después de procesarlo, la salida que recibimos es 1 2 3 5 14 60 645 .
Salida:
2. Selección de selección
- El orden de selección puede definirse como otro algoritmo para ordenar la lista en la que el conjunto se bifurca en dos conjuntos donde se supone que el primer conjunto está vacío, mientras que el segundo conjunto consiste en la lista de valores sin clasificar. El programa busca los valores más pequeños en la segunda matriz y cuando se encuentra el valor, se ha movido al comienzo de la primera matriz que estaba vacía. El enfoque se repite nuevamente y los siguientes valores más pequeños se desplazarán al segundo índice de la primera matriz. Los procesos seguirán repitiéndose hasta que la segunda matriz quede vacía.
- El siguiente programa es la implementación de codificación del algoritmo de selección de selección. Una vez que el programa se ejecute correctamente, solicitará al usuario que ingrese el recuento de valores que está dispuesto a ordenar. Una vez que se obtiene el recuento, el programa le pedirá al usuario que ingrese los valores para la matriz que debe clasificarse. El valor luego se procesa usando el bucle anidado para ordenar los números. La verificación de la condición if también ha estado involucrada aquí para verificar el número más pequeño.
- Los procesos se repetirán hasta que la primera lista esté llena de la lista ordenada. Mientras tanto, los programas mantienen su enfoque principal para verificar si la segunda matriz tiene valor y si se encuentra positiva, el programa vuelve a ejecutar el algoritmo de clasificación. Aunque clasifica la lista de manera fácil, puede llevar un poco más de tiempo en comparación con los otros algoritmos. Pero al final, el resultado que generará será el mismo que el de los otros algoritmos de clasificación.
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();
)
Al solicitar el recuento de elementos que deben clasificarse, el usuario ha proporcionado 6 en la salida a continuación. Posteriormente, los valores que se han ingresado son 25 65 36 86 96 45. Estos valores se almacenan en la matriz que se espera que se bifurque en dos matrices donde una estará vacía para almacenar la lista ordenada y la otra tendrá la lista sin clasificar . Después de procesar la entrada, el resultado fue 25 36 45 65 86 96. Esta pérdida se ha ordenado utilizando el orden de selección. Una vez que los seis valores se hayan movido a la primera matriz en la forma ordenada, la segunda matriz quedará vacía y el algoritmo terminará.
Salida:
3. Clasificación rápida
- Quicksort se puede definir como el otro algoritmo para ordenar la lista en la que el enfoque consiste en dividir la matriz en términos de valores mayores y menores que hasta que los valores completos se dividan en formas individuales. En este algoritmo, el valor del último índice de la matriz se ha seleccionado como un pivote y todos los valores más pequeños que el pivote se han desplazado a la matriz que se espera que ocurra a la izquierda del valor y los elementos que tienen un valor más alto que el pivote se desplazan a la matriz correcta. Nuevamente, se selecciona un pivote de la matriz recién formada que tenía los valores menores que el último valor de pivote. Del mismo modo, los valores más pequeños que el nuevo pivote se desplazarán a la matriz que quedará y los valores más que el nuevo pivote se desplazarán a la matriz derecha.
- El siguiente programa es la implementación de clasificación rápida utilizando el lenguaje de programación C. Una vez que se ejecute el programa, le pedirá al usuario la cantidad de elementos que desea ordenar. Según el recuento, el bucle for repetirá los tiempos estimados para recibir la entrada del usuario. La entrada se procesará utilizando las condiciones if junto con el bucle for para generar una lista ordenada. La matriz seguirá organizando los valores utilizando el valor de pivote hasta que se hayan verificado todos los valores para el valor más pequeño.
- La clasificación realizada con este algoritmo es demasiado rápida en comparación con los otros algoritmos de clasificación y es por eso que se ha denominado clasificación rápida. Quicksort es el único algoritmo que conduce a dividir la matriz hasta que todos los valores se separen en las matrices individuales. Luego se agregarán o agregarán en una sola matriz que se considera como la lista ordenada.
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);
)
)
En el resultado a continuación, el usuario confirmó que enviará 6 valores y formará una lista de datos ordenados. Después de proporcionar el recuento, los valores proporcionados por el usuario son 56, 35, 24, 86, 98, 2. La clasificación rápida se ha aplicado a estos valores y se ha generado la lista ordenada que tiene el valor 2, 24, 35, 56 86, 98.
Salida:
4. Combinar Ordenar
- La ordenación por fusión se puede definir como otro algoritmo de ordenación que realiza la ordenación segregando la matriz hasta el final cuando se convierte en un valor individual y luego agregándolas de manera que pueda convertirse en una matriz ordenada.
- El proceso consume mucho tiempo en comparación con los otros algoritmos rivales, pero se considera bastante eficiente en comparación con otros. Cuando se trata de ordenar una lista grande, este algoritmo funciona muy bien y, por lo tanto, es preferible para desarrollar la aplicación que tiene que procesar la 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);
)
Cuando se ejecuta el código anterior, primero le pide al usuario que proporcione la cantidad de elementos que desea ordenar. Una vez que se ha enviado el número, deberán proporcionar los valores de recuento igual que proporcionaron inicialmente. Una vez que se hayan enviado los valores, el algoritmo mantendrá esos valores en la matriz y lo procesará para transformar la matriz en la matriz ordenada. Después de que la matriz se ordena en orden ascendente, la salida se mostrará al usuario.
Salida:
5. Heapsort
- La ordenación del montón se puede definir como el algoritmo de ordenación que funciona buscando el elemento máximo en la lista y ubicándolo en el último. El algoritmo realiza la acción de forma recursiva hasta que la matriz se ordena de forma ascendente.
- Es muy tiempo tomar el proceso para elegir el valor máximo y moverlo al último y, por lo tanto, se considera un enfoque de clasificación menos eficiente cuando se trata de ordenar la lista grande. Sin embargo, funciona bien con la lista que tiene un número limitado de valores. A continuación se muestra la implementación de este algoritmo en el lenguaje de programación C junto con la salida.
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;
)
)
)
El funcionamiento de este algoritmo es el mismo que el de otros algoritmos de clasificación, ya que también ordena la lista en orden ascendente. Cuando se ejecuta el código escrito anteriormente, el usuario debe enviar el recuento de valores que ordenarán. Una vez que se envían los valores, el código los procesará para convertir la matriz en la ordenada. El resultado se mostrará eventualmente y se puede observar que los valores que ha enviado el usuario se han ordenado en orden ascendente.
Salida:
6. Ordenar por inserción
- La ordenación por inserción puede definirse como el algoritmo de ordenación que funciona moviendo el valor mínimo al comienzo de la lista de uno en uno. Este es un algoritmo de clasificación muy menos eficiente y no se encuentra adecuado para manejar la lista grande.
- Este enfoque de ordenar el algoritmo funciona muy lentamente y generalmente no es preferido en ninguna de las aplicaciones. Puede funcionar bien con la lista que tiene muy pocos números de elementos. Para las aplicaciones, que tienen el requisito de procesar algunos números de valores, pueden aprovechar este 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;
)
Cuando se ejecuta el programa, el usuario tendrá que ingresar la cantidad de valores que necesita ordenar. Posteriormente, los valores ingresados por el usuario se almacenarán en la matriz. Luego pasarán a procesamiento y mediante el uso de for loop y comprobación de condición, el valor mínimo se moverá al principio en cada recursión y terminará generando una matriz ordenada. Los valores se mostrarán al usuario al final del programa.
Salida:
Conclusión
El algoritmo de ordenación se usa para generar una lista ordenada que es una lista normal donde todos los valores se ordenan de una manera particular. La lista se ha utilizado con mucha frecuencia en la aplicación real para aportar algunas funcionalidades. En este artículo, hemos cubierto el ordenamiento de burbujas, el ordenamiento de selección y el ordenamiento rápido, mientras que hay varios otros algoritmos, como el ordenamiento por fusión, que también pueden aprovecharse para generar una lista ordenada. Entre todos los algoritmos de ordenación, quicksort funciona muy rápido y ayuda a ordenar la lista muy rápidamente. Los programas escritos aquí son básicamente para implementar estos algoritmos de clasificación utilizando el lenguaje de programación C. Si está dispuesto a implementar lo mismo en otros lenguajes de programación, puede usar la misma lógica y lo único que puede variar puede ser la sintaxis y las palabras clave.
Artículo recomendado
Esta ha sido una guía para la Clasificación en C. Aquí discutimos una introducción en Clasificación en C y diferentes tipos de clasificación junto con un código de muestra. También puede consultar nuestros otros artículos sugeridos para obtener más información:
- Patrones en programación C
- Palindrome en el Programa C
- Combinar Ordenar en Java
- Introducción a la clasificación en R
- Introducción a la ordenación en C ++
- Descripción general de la ordenación en PHP
- Heap Sort en Python
- Función de clasificación en Python con ejemplos