Sorteerimine C - Erinevad sorteerimistüübid koos näitega

• Sissejuhatus sorteerimisse C

Sissejuhatus sorteerimisse C

Rakenduses tunnevad arendajad tungivalt vajadust andmeid sorteerida, et võimaldada teatud funktsionaalsust. Andmete sortimiseks on mitu lähenemisviisi ja neid arvestatakse sorteerimise all nomenklatuuri järgi. Sorteerimise võib määratleda kui meetodit andmete järjestamiseks teatud viisil, mis järgib teatud järjekorda. Selles jaotises õpime C-programmeerimiskeelt kasutades sorteerimist. Sorteerimist on mitut tüüpi, näiteks mullide sorteerimine, merge sortimine, sortimise sortimine, sisestamise sorteerimine ja nii edasi. Teeme kodeerimist sorteerimismeetodite jaoks, mida rakenduses väga sageli kasutatakse. Koodid on teile saadaval tekstvormingus, nii et teil on seda koodi lihtne kasutada, kui väljund kuvatakse ekraanipildil, et saada ülevaade tegelikust väljundist, mis tuleb pärast programmi käivitamist.

Kuidas sorteeritakse C-s?

• Sorteerimise algoritmi alusel saab sortimist teha mitmel viisil. C-programmeerimiskeeles on meil loendi sortimiseks mitu lähenemisviisi. Mõiste sortimine tähendab andmete korrastamist kindlal viisil, tavaliselt kasvavas järjekorras. Ehkki andmete sortimise viis on kõigis sortimisalgoritmides erinev, on nende kõigi tulemus sama.
• Tavaliselt otsib programm sorteerimisel minimaalset arvu ja nihutab selle numbri loendi algusesse ja korrab samu otsinguid. Jällegi, kui teine ​​väike arv on ilmnenud, nihutatakse see loendi järgmisele tühikule kohe pärast esimest indeksit ja seda protsessi korratakse seni, kuni sortimisloend saadakse. Nii toimub sortimine C-programmeerimiskeeles.
• Kõigis nimekirja järjestamise viisides mängib massiiv C-programmeerimiskeeles väga olulist rolli. Igas algoritmis on massiivi kasutatud sorteeritavate elementide loendi salvestamiseks. Näiteks mullide sorteerimisel salvestatakse elemendid ühes massiivis ja massiivi väärtused on töödeldud, et teisendada need sorteeritud andmete loendiks.
• Valiku sortimisel on sama massiivi käsitletud kui kahte massiivi, kus esimest massiivi peetakse sorteeritud väärtuste määramiseks vabaks, samas kui teine ​​massiiv sisaldab sortimata loendit. Massiivi sorteerimiseks kasutatakse massiivide väärtusi üksikute muutujate hoidmise asemel väga sageli. Kõigist algoritmidest töötab kiire sortimine väga kiiresti ja on seetõttu nimetatud kiireks sortimiseks. Võrreldes teiste sortimisalgoritmidega võtab see palju vähem aega.

Sorteerimise tüübid C-s

1. Mullide sortimine

• Mullide sortimist võib määratleda kui sortimisalgoritmi, mis järgib lähenemisviisi asendada esimese indeksi väärtus massiivi väikseima väärtusega ja korrata seda seni, kuni loend on sorteeritud. See on väga lihtne viis sorteerimiseks. Sel moel massiivi sorteerimiseks tuleb massi jaoks väärtus enne masseerimise alustamist omistada.
• Allpool on programm massiivi sortimiseks mullide sortimise teel, kus väärtused on kasutajalt võetud. Kui programm on koostatud ja käivitatud, küsib see kasutajalt elementide arvu, mida nad sortida soovivad. Kui number on esitatud, palub programm kasutajal anda väärtused, mis on võrdsed nende antud arvuga. Väärtused salvestatakse massiivi ja neid töödeldakse edasi, kasutades silmuse jaoks pesastatud otsuseid koos massi sorteerimiseks otsuste tegemisega, kasutades nuppu „if”.
• Massiivis leitud esimene väikseim väärtus on viidud massiivi esimesse indeksi ja seejärel alustatakse uuesti otsimist, et leida teine ​​väikseim arv. Kui järgmine väikseim arv on leitud, asendab see teises indeksis oleva väärtuse ja protsessi korratakse, kuni massiiv koosneb järjestatud väärtuste loendist.

Kood

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

Kasutaja on esitanud sisendi 5 3 60 14 1 2 645. Algoritm on rakendatud massiivile, mis koosneb väärtustest kasutaja antud viisil ja pärast selle töötlemist on meie saadud väljund 1 2 3 5 14 60 645 .

Väljund:

2. Valiku sortimine

• Valiku sortimise võib määratleda veel ühe algoritmina nimekirja sortimiseks, milles massiiv on jagatud kaheks massiiviks, kus esimene massiiv peaks olema tühi, samas kui teine ​​massiiv koosneb sortimata väärtuste loendist. Programm otsib teise massiivi väikseimaid väärtusi ja kui väärtus on leitud, on see teisaldatud esimese tühja massiivi algusesse. Lähenemist korratakse uuesti ja järgmised väikseimad väärtused nihutatakse esimese massiivi teisele indeksile. Protsesse korratakse, kuni teine ​​massiiv tühjeneb.
• Allpool olev programm on valiku sortimisalgoritmi kodeerimine. Kui programm on edukalt käivitatud, palub ta kasutajal sisestada väärtuste arv, mida nad on nõus sorteerima. Kui arv on saadud, palub programm kasutajal sisestada sorteeritava massiivi väärtused. Seejärel töödeldakse väärtust numbrite sorteerimiseks, kasutades silmuste sisse pesa. Väikseima arvu kontrollimiseks on siin kaasatud ka tingimuste kontrollimine.
• Protsesse korratakse, kuni esimene loend on sorteeritud loendit täis. Vahepeal hoiavad programmid põhifookust, et kontrollida, kas teisel massiivil on väärtus, ja kui see leitakse positiivsena, käivitab programm uuesti sortimisalgoritmi. Ehkki see sorteerib nimekirja hõlpsalt, võib see teiste algoritmidega võrreldes pisut rohkem aega võtta. Kuid lõpuks on selle genereeritav tulemus sama, mis teistel sortimisalgoritmidel.

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

Sorteeritavate elementide arvu küsimisel esitas kasutaja allpool toodud väljundis 6. Hiljem on sisestatud väärtused 25 65 36 86 96 45. Need väärtused salvestatakse massiivis, mis eeldatavasti jaotatakse kahte massiivi, kus üks on sorteeritud loendi salvestamiseks tühi ja teine ​​sorteerimata nimekirja jaoks. . Pärast sisendi töötlemist oli tulemus 25 36 45 65 86 96. Kaotatud on sorteeritud valiku sortimise abil. Kui kõik kuus väärtust on järjestatud kujul esimesse massiivi teisaldatud, muutub teine ​​massiiv tühjaks ja algoritm lõpetatakse.

Väljund:

3. Kiire sortimine

• Quicksorti võib määratleda kui teise nimekirja sorteerimisalgoritmi, milles lähenemisviisiks on massiivi jagamine väärtustest suuremateks ja väiksemateks, kuni koguväärtused, kui need jaotada üksikuteks vormideks, moodustavad. Selles algoritmis on massiivi viimase indeksi väärtus valitud pöördepunktina ja kõik pöördevõrgust väiksemad väärtused on nihutatud massiivi, mis eeldatavasti ilmub väärtuse vasakpoolsuses ja suurema väärtusega elementide korral kui nihutatakse nihutatakse paremasse massiivi. Uuesti moodustatud massiivist valitakse jälle üks pöördepunkt, mille väärtused olid väiksemad kui viimane pöördepunkt. Samamoodi nihutatakse uuest pöördepunktist väiksemad väärtused vasakusse massiivi ja paremas massiivis nihutatakse rohkem kui uut pöördepunkti.
• Allpool olev programm on kiirsortimise rakendamine C-programmeerimiskeelt kasutades. Kui programm käivitub, küsib see kasutajalt elementide arvu, mida nad sortida soovivad. Arvestuse põhjal itereerib for silmus kasutajalt sisendi saamiseks hinnangulisi aegu. Sisendit töödeldakse sorditud loendi genereerimiseks if-tingimustega koos for-loop-iga. Massiiv korraldab väärtuste kinnituspunkti abil seni, kuni kõik väärtused on väikseima väärtuse kontrollimiseks.
• Selle algoritmi abil tehtud sortimine on teiste sortimisalgoritmidega võrreldes liiga kiire ja seetõttu on see nimetatud kiireks sortimiseks. Quicksort on ainus algoritm, mis viib massiivi jagamiseni, kuni kõik väärtused on eraldatud üksikuteks massiivideks. Seejärel lisatakse need või koondatakse need ühte massiivi, mida loetakse sorteeritud loendiks.

Kood:

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

Allpool toodud väljundis kinnitas kasutaja, et nad saadavad 6 väärtust ja moodustavad sorteeritud andmete loendi. Pärast loenduse esitamist on kasutaja antud väärtused 56, 35, 24, 86, 98, 2. Nendele väärtustele on rakendatud kiirsort ja koostatud on sorteeritud loend, mille väärtus on 2, 24, 35, 56, 86, 98.

Väljund:

4. Ühenda sortimine

• Ühendamise sorteerimist võib määratleda kui teist sortimisalgoritmi, mis viib sortimise läbi massiivi eraldamisega viimaseks, kuni see muutub individuaalseks väärtuseks, ja seejärel koondada need viisil, et see võiks muutuda sorteeritud massiiviks.
• Protsess võtab teiste konkureerivate algoritmidega võrreldes pisut palju aega, kuid seda peetakse teistega võrreldes üsna tõhusaks. Suure nimekirja sorteerimisel töötab see algoritm väga hästi ja on seetõttu eelistatud suure loendi töötlemiseks mõeldud rakenduse väljatöötamisel.

Kood:

#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);
)
Ülaltoodud koodi käivitamisel palub see kasutajal kõigepealt sisestada elementide arvu, mida nad sortida soovivad. Kui number on esitatud, peavad nad esitama algselt antud võrdse arvu väärtused. Kui väärtused on esitatud, hoiab algoritm neid väärtusi massiivis ja töötleb seda massiivi teisendamiseks massiiviks. Pärast massiivi sorteerimist kasvavas järjekorras kuvatakse kasutajale väljund.

Väljund:

5. Heapsort

• Hunniku sortimist saab määratleda sortimisalgoritmina, mis töötab otsides loendist maksimaalse elemendi ja asetades selle viimasele. Algoritm viib toimingu läbi rekursiivselt, kuni massiiv sorteeritakse tõusvas suunas.
• Maksimaalse väärtuse valimiseks ja viimasele viimiseks on vaja väga aega, ja seetõttu peetakse seda suure nimekirja sorteerimisel vähem tõhusaks sortimismeetodiks. Kuid see töötab hästi nimekirjaga, millel on piiratud arv väärtusi. Allpool on esitatud selle algoritmi rakendamine C-programmeerimiskeeles koos väljundiga.

Kood:

#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;
)
)
)
Selle algoritmi tööpõhimõte on sama nagu teiste sortimisalgoritmide töö, kuna see sorteerib loendi ka kasvavas järjekorras. Ülaltoodud koodi käivitamisel peab kasutaja esitama sorteeritavate väärtuste arvu. Kui väärtused on esitatud, töötleb kood neid massiivi sorteerituks muutmiseks. Väljundit näidatakse lõpuks ja võib täheldada, et kasutaja esitatud väärtused on järjestatud kasvavas järjekorras.

Väljund:

6. Sisestuse sortimine

• Sisestussorteerimise võib määratleda kui sortimisalgoritmi, mis toimib minimaalse väärtuse nihutamisega loendi alguses ükshaaval. See on väga vähem efektiivne sortimisalgoritm, mida ei leita sobivaks suure nimekirjaga tegelemiseks.
• Algoritmi sortimise selline lähenemisviis töötab väga aeglaselt ja tavaliselt ei eelistata seda üheski rakenduses. See võib hästi töötada loendiga, milles on üsna vähe elemente. Rakenduste jaoks, millel on kohustus töödelda mõni arv väärtusi, saab seda algoritmi kasutada.

Kood:

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

Programmi käivitamisel peab kasutaja sisestama sorteerimiseks vajalike väärtuste arvu. Pärast seda salvestatakse kasutaja sisestatud väärtused massiivi. Seejärel töödeldakse neid ja silmuste ning seisundi kontrollimiseks liigutatakse minimaalne väärtus iga rekursiooni algusesse ja genereeritakse sorteeritud massiiv. Väärtused kuvatakse kasutajale programmi lõpus.

Väljund:

Järeldus

Sorteerimisalgoritmi kasutatakse sorteeritud loendi genereerimiseks, mis on tavaline loend, kus kõik väärtused sorteeritakse kindlal viisil. Loendit on tegelikus rakenduses kasutatud väga sageli, et tuua sisse mõned funktsioonid. Selles artiklis oleme hõlmanud mullide sorteerimist, sortimist sorteerimist ja kiirsortimist, kuid on ka mitmeid teisi algoritme, näiteks liitmis sortimine, mida saab kasutada sorteeritud loendi genereerimiseks. Kõigist sortimisalgoritmidest töötab quicksort väga kiiresti ja aitab nimekirja väga kiiresti sorteerida. Siia kirjutatud programmid on mõeldud põhiliselt nende sortimisalgoritmide rakendamiseks, kasutades C-programmeerimiskeelt. Kui olete nõus rakendama sama teistes programmeerimiskeeltes, võite kasutada sama loogikat ja ainus, mis võib erineda, võib olla süntaks ja märksõnad.

Soovitatav artikkel

See on olnud juhend sorteerimiseks C-s. Siin käsitleme sissejuhatust sortimises C-s ja erinevaid sorteerimistüüpe koos näidiskoodiga. Lisateavet leiate ka meie muudest soovitatud artiklitest -

1. C-programmeerimise mustrid
2. C-programmi palindroom
3. Ühenda sortimine Java-s
4. Sissejuhatus sorteerimisse R
5. Sissejuhatus sortimisse C ++
6. Ülevaade sortimisest PHP-s
7. Hunnik sorteerimine Pythonis
8. Näite abil sortimisfunktsioon Pythonis