Introduktion til sortering i C

I applikationen føler udviklerne trang til at sortere dataene for at lade bringe særlig funktionalitet. Der er flere tilgange til at sortere dataene, og de tælles under sortering i henhold til nomenklaturen. Sortering kan defineres som metoden til at arrangere dataene på en bestemt måde, der følger en eller anden rækkefølge. Her i dette afsnit skal vi lære om sortering ved hjælp af programmeringssproget C. Der er flere typer sortering som f.eks. Boblesortering, sammenfletningssortering, valgsortering, indsættelsessortering og så videre. Vi foretager faktisk kodning for de sorteringsmetoder, der ofte bruges i applikationen. Koderne vil være tilgængelige for dig i et tekstformat, så du kan finde det nemt at bruge den kode, mens output vises i skærmbillede for at give dig indsigt i den faktiske output, der kommer efter at have kørt programmet.

Hvordan sorteres der i C?

  • Sortering kan udføres på forskellige måder baseret på sorteringsalgoritmen. I programmeringssprog C har vi flere tilgange til at sortere listen. Udtrykket sortering angiver arrangering af data på en bestemt måde normalt i stigende rækkefølge. Selvom måden til sortering af data er forskellig i alle sorteringsalgoritmerne, er resultatet af dem alle det samme.
  • Normalt søger programmet efter sortering efter det minimale antal og flyttede dette nummer til starten af ​​listen og gentager de samme søgninger. Når det andet lille antal igen er fundet, skiftes det til det næste rum på listen lige efter det første indeks, og denne proces fortsætter med at gentage, indtil sorteringslisten opnås. Sådan sorteres på C-programmeringssprog.
  • I alle fremgangsmåder til sortering af listen spiller arrayet en meget vigtig rolle i programmeringssprog C. I hver algoritme er arrayet blevet brugt til at gemme listen over de elementer, der skal sorteres. I boblesortering lagres elementerne for eksempel i den enkelte array, og værdierne i arrayet er blevet behandlet for at konvertere dem til en liste med sorterede data.
  • I markeringen er den samme matrix blevet behandlet som to matriser, hvor den første matrix betragtes som ledig for at fortælle de sorterede værdier, mens den anden array indeholder den usorterede liste. For at tjene formålet med at sortere matrixen bruges meget ofte i stedet for at holde værdierne i individuelle variabler. Blandt alle algoritmerne fungerer hurtig sortering meget hurtig og dermed kaldes hurtig sortering. Det tager meget mindre tid sammenlignet med de andre sorteringsalgoritmer.

Typer af sortering i C

1. Bubble Sort

  • Boblesortering kan defineres som den sorteringsalgoritme, der følger fremgangsmåden med at udskifte værdien i det første indeks med den mindste værdi i matrixen og holde den gentaget, indtil listen er sorteret. Det er en meget enkel måde at udføre sortering på. På denne måde for at sortere matrixen, skal værdien tildeles arrayen i starten, inden sorteringen startes.
  • Nedenfor er programmet til at sortere matrixen ved hjælp af boble-sortering, hvor værdierne er taget fra brugeren. Når programmet er samlet og kørt, vil det bede brugeren om antallet af elementer, de vil sortere. Når nummeret er angivet, beder programmet brugeren om at give værdier svarende til det antal, de har givet. Værdierne gemmes i matrixen og behandles yderligere ved hjælp af nested for loop sammen med beslutningstagning ved hjælp af "if" for at sortere matrixen.
  • Den første mindste værdi fundet i matrixen er flyttet til den første indeks for arrayen, og derefter begynder søgningen igen for at finde det andet mindste tal. Når det næste mindste nummer er fundet, erstatter det værdien i det andet indeks, og processen bliver ved med at gentage, indtil arrayet består af en sorteret liste over værdier.

Kode

#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;
)

Brugeren har indsendt input 5 3 60 14 1 2 645. Algoritmen er blevet anvendt på den matrix, der består af værdier på den måde, den leveres af brugeren, og efter behandling af den er den modtagne output 1 2 3 5 14 60 645 .

Produktion:

2. Valgssortering

  • Valgsorten kan defineres som en anden algoritme til sortering af listen, hvor arrayet er opdelt i to arrays, hvor det første array antages at være tomt, mens det andet array består af den usorterede liste over værdier. Programmet søger efter de mindste værdier i den anden matrix, og når værdien findes, er den flyttet til begyndelsen af ​​den første array, der var tom. Fremgangsmåden gentages igen, og de næste mindste værdier flyttes til det andet indeks i den første matrix. Processerne fortsætter med at gentage, indtil det andet array blev tomt.
  • Det nedenstående program er kodningsimplementeringen af ​​algoritmen til valg af sortering. Når programmet kører med succes, vil det bede brugeren om at indtaste antallet af værdier, som de er villige til at sortere. Når optællingen er opnået, beder programmet brugeren om at indtaste værdierne for den matrix, der skal sorteres. Værdien behandles derefter ved hjælp af indlejret for loop for at sortere numrene. Hvis tilstandskontrol er også involveret her for at kontrollere det mindste antal.
  • Processerne gentages, indtil den første liste er fuld af den sorterede liste. I mellemtiden holder programmerne sit primære fokus for at kontrollere, om den anden matrix har værdi, og hvis den findes positiv, kører programmet sorteringsalgoritmen igen. Selvom det sorteres listen på nem måde, kan det tage lidt mere tid sammenlignet med de andre algoritmer. Men til sidst vil resultatet, det genererer, være det samme som de andre sorteringsalgoritmer.

Kode
#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();
)

Når brugeren har bedt om antallet af elementer, der skal sorteres, har brugeren leveret 6 i nedenstående output. Senere er de indtastede værdier 25 65 36 86 96 45. Disse værdier gemmes i den matrix, som forventes at blive delt i to arrays, hvor den ene vil være tom for at gemme den sorterede liste, og den anden har den usorterede liste . Efter behandling af input var resultatet 25 36 45 65 86 96. Dette tabte er blevet sorteret ved hjælp af markeringen. Når alle de seks værdier er flyttet til den første matrix i den sorterede form, bliver den anden array tom, og algoritmen afsluttes.

Produktion:

3. Hurtig sortering

  • Quicksort kan defineres som den anden algoritme til sortering af listen, hvor fremgangsmåden er at opdele arrayet i form af større end og mindre end værdier, indtil hele værdierne, hvis de er opdelt i individer, dannes. I denne algoritme er værdien af ​​det sidste indeks i arrayet valgt som en pivot, og alle værdier, der er mindre end pivot, er flyttet til den matrix, der forventes at forekomme til venstre for værdien, og elementerne, der har en højere værdi end pivoten flyttes til det rigtige array. Igen vælges en pivot fra den nydannede matrix, der havde værdierne mindre end den sidste pivotværdi. Tilsvarende flyttes værdier, der er mindre end den nye pivot, til den matrix, der vil være tilbage, og værdierne mere end den nye pivot forskydes i den højre array.
  • Nedenstående program er implementeringen af ​​quicksort ved hjælp af programmeringssproget C. Når programmet kører, vil det bede brugeren om antallet af elementer, de vil sortere. Baseret på tællingen vil for-loopen estimere estimerede tidspunkter for at tage input fra brugeren. Inputet behandles ved hjælp af if-betingelserne sammen med for-loop for at generere en sorteret liste. Array'en fortsætter med at arrangere værdierne ved hjælp af drejeværdien, indtil alle værdier er kontrolleret for den mindste værdi.
  • Sorteringen, der udføres ved hjælp af denne algoritme, er alt for hurtigere sammenlignet med de andre sorteringsalgoritmer, og det er derfor, den har fået navnet hurtig sortering. Quicksort er den eneste algoritme, der fører til opdeling af matrixen, indtil alle værdier er adskilt i de enkelte arrays. De tilføjes eller aggregeres derefter i en enkelt matrix, der betragtes som den sorterede liste.

Kode:

#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);
)
)

I nedenstående output bekræftede brugeren, at de vil indsende 6 værdier og til at danne en liste med sorterede data. Efter tilvejebringelse af tællingen er værdierne, der er leveret af brugeren, 56, 35, 24, 86, 98, 2. Quicksort er blevet anvendt på disse værdier, og den sorterede liste er genereret, der har værdien 2, 24, 35, 56, 86, 98.

Produktion:

4. Flet sortering

  • Flettesortering kan defineres som en anden sorteringsalgoritme, der udfører sorteringen ved at adskille arrayen indtil sidst, når den bliver til en individuel værdi og derefter aggregerer dem på en måde, så den kan blive til en sorteret matrix.
  • Processen bruger lidt meget tid sammenlignet med de andre rivaliserende algoritmer, men den betragtes som temmelig effektiv sammenlignet med andre. Når det kommer til sortering af en stor liste, fungerer denne algoritme meget fint og foretrækkes derfor ved at udvikle den applikation, der skal behandle den store liste.

Kode:

#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);
)
Når koden ovenfor kører, beder den først brugeren om at angive antallet af elementer, de vil sortere. Når nummeret er indsendt, skal de angive værdierne for det samme antal, som de oprindeligt har angivet. Når værdierne er blevet indsendt, vil algoritmen indeholde disse værdier i matrixen og vil behandle den til at omdanne arrayen til den sorterede array. Når arrayet er sorteret i stigende rækkefølge, vises output for brugeren.

Produktion:

5. Heapsort

  • Heap-sorteringen kan defineres som den sorteringsalgoritme, der fungerer ved at søge efter det maksimale element på listen og placere det til det sidste. Algoritmen udfører handlingen rekursivt, indtil arrayet bliver sorteret på stigende måde.
  • Det er meget tid at tage processen til at vælge den maksimale værdi og flytte den til den sidste, og det betragtes derfor som en mindre effektiv sorteringsmetode, når det kommer til sortering af den store liste. Det fungerer dog fint med listen, der har et begrænset antal værdier. Nedenfor er implementeringen af ​​denne algoritme i programmeringssprog C sammen med output.

Kode:

#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;
)
)
)
Arbejdet med denne algoritme er den samme som for andre sorteringsalgoritmer, da den også sorterer listen i stigende rækkefølge. Når koden ovenfor er kørt, skal brugeren indsende antallet af værdier, de vil sortere. Når værdierne er indsendt, behandler koden dem for at gøre arrayet til det sorterede. Outputet vises til sidst, og det kan observeres, at de værdier, der er indsendt af brugeren, er sorteret i stigende rækkefølge.

Produktion:

6. Indsættelsessortering

  • Indsættelsessortering kan defineres som den sorteringsalgoritme, der fungerer ved at flytte minimumsværdien i begyndelsen af ​​listen én ad gangen. Dette er en meget mindre effektiv sorteringsalgoritme og ikke fundet egnet til at håndtere den store liste.
  • Denne fremgangsmåde til sortering af algoritmen fungerer meget langsomt og foretrækkes normalt ikke i nogen af ​​applikationerne. Det kan fungere godt med listen, der har temmelig få antal elementer. For applikationer, der har kravet om at behandle et par antal værdier, kan udnytte denne algoritme.

Kode:

#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;
)

Når programmet kører, skal brugeren indtaste det antal værdier, de har brug for at sortere. Bagefter gemmes de af brugeren indtastede værdier i matrixen. De går derefter under behandling og ved brug af til loop- og tilstandskontrol flyttes minimumsværdien til begyndelsen i hver rekursion og ender med at generere en sorteret matrix. Værdierne vises for brugeren efter programmets afslutning.

Output:

Konklusion

Sorteringsalgoritmen bruges til at generere en sorteret liste, som er en normal liste, hvor alle værdier sorteres på en bestemt måde. Listen er blevet brugt meget ofte i den egentlige applikation til at bringe nogle funktionaliteter. I denne artikel har vi dækket boble sortering, markering sortering og quicksort, mens der er flere andre algoritmer som fusion sortering er også der, der kan udnyttes til at generere en sorteret liste. Blandt alle sorteringsalgoritmerne fungerer quicksort meget hurtigt og hjælper med at sortere listen meget hurtigt. De programmer, der er skrevet her, er dybest set til at implementere disse sorteringsalgoritmer ved hjælp af programmeringssproget C. Hvis du er villig til at implementere det samme på andre programmeringssprog, kan du bruge den samme logik, og det eneste, der kan variere, kan være syntaks og nøgleord.

Anbefalet artikel

Dette har været en guide til sortering i C. Her diskuterer vi en introduktion i sortering i C og forskellige typer sortering sammen med prøvekode. Du kan også gennemgå vores andre foreslåede artikler for at lære mere -

  1. Mønstre i C-programmering
  2. Palindrome in C-program
  3. Flet sortering i Java
  4. Introduktion til sortering i R
  5. Introduktion til sortering i C ++
  6. Oversigt over sortering i PHP
  7. Heap Sort i Python
  8. Sorteringsfunktion i Python med eksempler

Kategori:

Softwareudvikling