Lajittelu C - Erityyppiset lajittelut, kuten esimerkki

• Johdanto lajitteluun C: ssä

Johdanto lajitteluun C: ssä

Sovelluksessa kehittäjät tuntevat halua lajitella tiedot tietyn toiminnallisuuden tuomiseksi. Tietojen lajittelussa on useita lähestymistapoja, ja ne lasketaan lajitteluun nimikkeistön mukaisesti. Lajittelu voidaan määritellä menetelmäksi tietojen järjestämiseksi tietyllä tavalla, joka noudattaa jotakin järjestystä. Tässä tässä osiossa opimme lajitteluun C-ohjelmointikielen avulla. Lajittelua on useita tyyppejä, kuten kuplalajittelu, yhdistämislaji, valintalaji, lisäyslajittelu ja niin edelleen. Teemme varsinaisen koodauksen lajittelumenetelmille, joita käytetään sovelluksessa hyvin usein. Koodit ovat sinulle saatavana tekstimuodossa, jotta on helppoa käyttää tätä koodia, kun lähtö näkyy kuvakaappauksessa antaaksesi sinulle kuvan todellisesta tuotosta, joka tulee ohjelman suorittamisen jälkeen.

Kuinka lajittelu suoritetaan C: ssä?

• Lajittelu voidaan suorittaa eri tavoin lajittelualgoritmin perusteella. C-ohjelmointikielellä meillä on useita tapoja lajitella luettelo. Termi lajittelu tarkoittaa tietojen järjestämistä tietyllä tavalla yleensä nousevassa järjestyksessä. Vaikka tapa lajitella tiedot on erilainen kaikissa lajittelualgoritmeissa, niiden kaikkien tulos on sama.
• Yleensä lajitellessaan ohjelma etsii vähimmäismäärää ja siirtää numeron luettelon alkuun ja toistaa samat haut. Jälleen kerran, kun toinen pieni numero on kohdattu, se siirretään seuraavaan luettelotilaan heti ensimmäisen hakemiston jälkeen ja tätä prosessia jatketaan toistamiseen, kunnes lajitteluluettelo saadaan. Tällä tavalla lajittelu tapahtuu C-ohjelmointikielellä.
• Kaikissa luettelon lajittelutavoissa taulukolla on erittäin tärkeä rooli C-ohjelmointikielessä. Jokaisessa algoritmissa taulukkoa on käytetty tallentamaan lajiteltavien elementtien luettelo. Esimerkiksi kuplalajittelu, elementit tallennetaan yksittäiseen taulukkoon ja taulukon arvot on käsitelty muuntamaan ne lajiteltujen tietojen luetteloksi.
• Valintalajittelussa samaa taulukkoa on käsitelty kahtena taulukkona, joissa ensimmäisen taulukon katsotaan olevan tyhjä lajiteltujen arvojen ilmoittamiseksi, kun taas toisessa taulukossa on lajittelematon luettelo. Matriisin lajittelua varten käytetään hyvin usein yksittäisten muuttujien arvojen pitämisen sijaan. Kaikista algoritmeista nopea lajittelu toimii erittäin nopeasti, ja siksi se on nimetty pikalajitteluksi. Se vie paljon vähemmän aikaa verrattuna muihin lajittelualgoritmeihin.

Lajittelulajit C: ssä

1. Kuplalajittelu

• Kuplalajittelu voidaan määritellä lajittelualgoritmiksi, joka seuraa lähestymistapaa korvata ensimmäisen hakemiston arvo matriisin pienimmällä arvolla ja pitää sitä toistamassa, kunnes luettelo on lajiteltu. Se on hyvin yksinkertainen tapa lajitella. Tällä tavalla taulukon järjestämiseksi arvo on annettava taulukolle alussa ennen lajittelun aloittamista.
• Alla on ohjelma, jolla lajitellaan taulukko kuplalajittelua käyttämällä, kun arvot on otettu käyttäjältä. Kun ohjelma on koottu ja suoritettu, se kysyy käyttäjältä lukumäärää elementtejä, jotka he haluavat lajitella. Kun numero on annettu, ohjelma pyytää käyttäjää antamaan arvot, jotka vastaavat heidän antamaansa määrää. Arvot tallennetaan taulukkoon ja prosessoidaan edelleen käyttämällä sisäkkäisiä silmukoita yhdessä päätöksenteon kanssa käyttämällä "jos" taulukon lajitteluun.
• Ensimmäinen taulukossa löydetty arvo on siirretty taulukon ensimmäiseen hakemistoon ja sitten haku alkaa uudelleen toisen pienimmän luvun löytämiseksi. Kun seuraava pienin luku on löydetty, se korvaa toisen indeksin arvon ja prosessi jatkuu toistuvasti, kunnes taulukko koostuu lajiteltujen arvojen luettelosta.

Koodi

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

Käyttäjä on lähettänyt syötteen 5 3 60 14 1 2 645. Algoritmia on sovellettu arvoista koostuvaan taulukkoon käyttäjän tarjoamalla tavalla ja prosessoinnin jälkeen vastaanottamamme lähtö on 1 2 3 5 14 60 645 .

lähtö:

2. Valintalajittelu

• Valintaluokka voidaan määritellä toisena algoritmina sen luettelon lajitteluun, jossa taulukko on hajotettu kahteen taulukkoon, joissa ensimmäisen taulukon oletetaan olevan tyhjä, kun taas toinen taulukko koostuu lajittelemattomasta arvoluettelosta. Ohjelma etsii pienimmät arvot toisesta taulukosta ja kun arvo löytyy, se on siirretty ensimmäisen tyhjän taulukon alkuun. Lähestymistapa toistetaan uudelleen ja seuraavat pienimmät arvot siirretään ensimmäisen taulukon toiseen indeksiin. Prosessit jatkavat toistamista, kunnes toinen taulukko tyhjeni.
• Alla oleva ohjelma on valintalajittelualgoritmin koodaus-toteutus. Kun ohjelma on suoritettu onnistuneesti, se pyytää käyttäjää syöttämään niiden arvojen määrän, jotka he ovat valmiita lajittelemaan. Kun laskenta on saatu, ohjelma pyytää käyttäjää syöttämään lajiteltavan taulukon arvot. Arvo käsitellään sitten käyttämällä sisäkkäisiä silmukoita numeroiden lajittelua varten. Jos olosuhteiden tarkistamiseen on käytetty myös täällä pienimmän määrän tarkistamiseksi.
• Prosessit toistetaan, kunnes ensimmäinen luettelo on täynnä lajiteltua luetteloa. Samanaikaisesti ohjelmat pitävät ensisijaista keskittymistään tarkistaakseen, onko toisella taulukolla arvoa, ja jos se todetaan positiiviseksi, ohjelma ajaa lajittelualgoritmin uudelleen. Vaikka se lajittelee luettelon helposti, se voi viedä hieman enemmän aikaa verrattuna muihin algoritmeihin. Mutta loppujen lopuksi sen tuottama tulos on sama kuin muut lajittelualgoritmit.

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

Pyydettäessä lajiteltavien elementtien määrää käyttäjä on antanut 6 alla olevaan tuotokseen. Myöhemmin syötetyt arvot ovat 25 65 36 86 96 45. Nämä arvot tallennetaan taulukkoon, jonka oletetaan jakautuvan kahteen taulukkoon, joista toinen on tyhjä lajiteltujen luetteloiden tallentamiseksi ja toinen lajittelematta. . Syötteen käsittelyn jälkeen tulos oli 25 36 45 65 86 96. Tämä menetetty on lajiteltu valintalajittelulla. Kun kaikki kuusi arvoa on siirretty ensimmäiseen järjestettyyn taulukkoon, toinen taulukko tyhjenee ja algoritmi lopetetaan.

lähtö:

3. Pikalajittelu

• Quicksort voidaan määritellä toiseksi algoritmiksi lajitellaksesi luetteloa, jossa lähestymistapana on jakaa taulukko arvoja suurempina ja pienemminä, kunnes koko arvot, jos ne jaetaan yksilöihin, muodostavat. Tässä algoritmissa taulukon viimeisen indeksin arvo on valittu niveliksi ja kaikki pivota pienemmät arvot on siirretty taulukkoon, jonka odotetaan tapahtuvan arvon vasemmalla puolella ja elementeillä, joilla on suurempi arvo kuin nivel siirretään oikeaan taulukkoon. Jälleen yksi nivel valitaan äskettäin muodostetusta ryhmästä, jonka arvot olivat pienemmät kuin viimeinen pivot-arvo. Samoin uutta kääntöpistettä pienemmät arvot siirretään vasempaan taulukkoon ja uutta kääntöpistettä suuremmat arvot siirretään oikeassa taulukossa.
• Alla oleva ohjelma on pikavalinta C-ohjelmointikielellä. Kun ohjelma on käynnissä, se kysyy käyttäjältä lukumäärää elementtejä, jotka he haluavat lajitella. Laskennan perusteella for-silmukka iteroi arvioidut ajat, jotta käyttäjä voi syöttää tulon. Tuloa käsitellään if-olosuhteissa yhdessä for-silmukan kanssa lajiteltujen luetteloiden muodostamiseksi. Taulukko järjestää arvoja edelleen kääntöarvon avulla, kunnes kaikki arvot on tarkistettu pienimmälle.
• Tätä algoritmia käyttävä lajittelu on aivan liian nopeata verrattuna muihin lajittelualgoritmeihin, ja siksi se on nimetty nopeaksi lajitteluun. Quicksort on ainoa algoritmi, joka johtaa taulukon jakamiseen, kunnes kaikki arvot on jaettu yksittäisiin ryhmiin. Ne lisätään tai yhdistetään sitten yhteen taulukkoon, jota pidetään lajiteltuna luettelona.

Koodi:

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

Alla olevassa tulostuksessa käyttäjä vahvisti lähettävänsä 6 arvoa ja muodostavansa lajiteltujen tietojen luettelon. Laskennan antamisen jälkeen käyttäjän antamat arvot ovat 56, 35, 24, 86, 98, 2. Näihin arvoihin on käytetty pikavalintaa ja on luotu lajiteltu luettelo, jolla on arvot 2, 24, 35, 56, 86, 98.

lähtö:

4. Yhdistä lajittelu

• Yhdistämislajittelu voidaan määritellä toiseksi lajittelualgoritmiksi, joka suorittaa lajittelun erottamalla taulukon viimeiseen, kun se muuttuu yksilölliseksi arvoksi ja yhdistämällä sitten ne siten, että se voisi muuttua lajiteltuksi taulukkoksi.
• Prosessi vie vähän aikaa verrattuna muihin kilpaileviin algoritmeihin, mutta sitä pidetään melko tehokkaana muihin verrattuna. Kun kyse on suuren luettelon lajittelusta, tämä algoritmi toimii erittäin hyvin ja on siksi suositeltavampi kehitettäessä sovellusta, jonka on käsiteltävä suuri luettelo.

Koodi:

#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);
)
Kun yllä oleva koodi suoritetaan, se pyytää ensin käyttäjää antamaan määrä elementtejä, jotka he haluavat lajitella. Kun numero on lähetetty, heidän on annettava alun perin antamat yhtä suuret arvot. Kun arvot on toimitettu, algoritmi pitää nämä arvot taulukossa ja käsittelee sen muuttamaan taulukko lajiteltuun taulukkoon. Kun taulukko on lajiteltu nousevaan järjestykseen, ulostulo näytetään käyttäjälle.

lähtö:

5. Heapsort

• Kasalajittelu voidaan määritellä lajittelualgoritmiksi, joka toimii etsimällä luettelon maksimielementti ja sijoittamalla se viimeiseen. Algoritmi suorittaa toiminnan rekursiivisesti, kunnes taulukko lajitellaan nousevaan tapaan.
• On erittäin aika ottaa prosessi valita enimmäisarvo ja siirtää se viimeiseen, ja siksi sitä pidetään vähemmän tehokkaana lajittelutavana, kun kyse on suuren luettelon lajittelusta. Se toimii kuitenkin hyvin luettelossa, jolla on rajoitettu määrä arvoja. Alla on tämän algoritmin toteutus C-ohjelmointikielellä yhdessä lähdön kanssa.

Koodi:

#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;
)
)
)
Tämän algoritmin toiminta on sama kuin muiden lajittelualgoritmien, koska se myös lajittelee luettelon nousevassa järjestyksessä. Kun yllä oleva kirjoitettu koodi suoritetaan, käyttäjän on toimitettava lajittelevien arvojen lukumäärä. Kun arvot on toimitettu, koodi käsittelee ne, jotta taulukko muuttuu lajiteltuksi. Tulos näytetään lopulta ja voidaan havaita, että käyttäjän toimittamat arvot on lajiteltu nousevassa järjestyksessä.

lähtö:

6. Lisäyslajittelu

• Lisäyslajittelu voidaan määritellä lajittelualgoritmiksi, joka toimii siirtämällä minimiarvoa luettelon alussa yksi kerrallaan. Tämä on erittäin tehoton lajittelualgoritmi, jota ei löydy sopivasta käsittelemään suurta luetteloa.
• Tämä algoritmin lajittelutapa toimii hyvin hitaasti eikä yleensä ole suositeltavaa missään sovelluksessa. Se voi toimia hyvin luettelossa, jossa on melko vähän elementtejä. Sovelluksissa, joissa vaaditaan prosessoimaan muutama luku arvoja, voidaan hyödyntää tätä algoritmia.

Koodi:

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

Kun ohjelma suoritetaan, käyttäjän on syötettävä määrä arvoja, jotka he tarvitsevat lajitellaan. Myöhemmin käyttäjän syöttämät arvot tallennetaan taulukkoon. Sitten ne käsitellään prosessoinnissa ja silmukan ja tilan tarkistamisessa minimiarvo siirretään jokaisen rekursion alkuun ja lopulta generoidaan lajiteltu taulukko. Arvot näytetään käyttäjälle ohjelman lopussa.

Tulos:

johtopäätös

Lajittelualgoritmia käytetään luomaan lajiteltu luettelo, joka on normaali luettelo, jossa kaikki arvot lajitellaan tietyllä tavalla. Listaa on käytetty hyvin usein todellisessa sovelluksessa joidenkin toimintojen tuomiseksi. Tässä artikkelissa olemme käsittäneet kuplan lajittelun, lajittelun ja nopean lajittelun, vaikka olemassa on myös useita muita algoritmeja, kuten yhdistämislajittelu, joita voidaan hyödyntää lajitellun luettelon luomiseksi. Kaikista lajittelualgoritmeista quicksort toimii erittäin nopeasti ja auttaa lajittelemaan luettelon nopeasti. Tässä kirjoitetut ohjelmat ovat periaatteessa näiden lajittelualgoritmien toteuttamiseksi C-ohjelmointikieltä käyttämällä. Jos olet halukas ottamaan saman käyttöön muilla ohjelmointikielellä, voit käyttää samaa logiikkaa ja ainoa asia, joka saattaa vaihdella, voi olla syntaksi ja avainsanat.

Suositeltava artikkeli

Tämä on opas lajitteluun C: ssä. Tässä keskustellaan C-lajittelua koskevasta johdannosta ja erityyppisistä lajittelukohdista yhdessä näytekoodin kanssa. Voit myös käydä läpi muiden ehdotettujen artikkeleidemme saadaksesi lisätietoja -

1. Kuviot C-ohjelmoinnissa
2. Palindromi C-ohjelmassa
3. Yhdistä Järjestä Java
4. Johdatus lajitteluun R: ssä
5. Johdanto lajitteluun C ++: ssa
6. Katsaus lajitteluun PHP: ssä
7. Heap Sort Pythonissa
8. Järjestämistoiminto Pythonissa esimerkkien avulla