Triedenie v C Rôzne typy triedenia spolu s príkladom

• Úvod do triedenia v C

Úvod do triedenia v C

V aplikácii cítia vývojári nutnosť triediť údaje, aby priniesli osobitnú funkčnosť. Existuje niekoľko prístupov k triedeniu údajov a tieto sa započítavajú do triedenia podľa nomenklatúry. Zoradenie možno definovať ako spôsob usporiadania údajov konkrétnym spôsobom, ktorý nasleduje určité poradie. V tejto časti sa dozvieme o triedení pomocou programovacieho jazyka C. Existuje niekoľko druhov zoradenia, ako sú bublinové, zlúčené, výberové, vložené a podobne. Urobíme skutočné kódovanie pre metódy triedenia, ktoré sa v aplikácii používajú veľmi často. Kódy vám budú k dispozícii v textovom formáte, takže je pre vás ľahké použiť tento kód, zatiaľ čo výstup sa zobrazí na snímke obrazovky, aby ste získali prehľad o skutočnom výstupe, ktorý príde po spustení programu.

Ako sa triedenie vykonáva v C?

• Triedenie sa môže vykonávať rôznymi spôsobmi na základe triediaceho algoritmu. V programovacom jazyku C máme niekoľko prístupov na zoradenie zoznamu. Termín triedenie uvádza usporiadanie údajov konkrétnym spôsobom zvyčajne vo vzostupnom poradí. Aj keď spôsob triedenia údajov je vo všetkých triediacich algoritmoch odlišný, výsledok všetkých z nich je rovnaký.
• Program zvyčajne pri triedení vyhľadáva minimálny počet a posúva toto číslo na začiatok zoznamu a opakuje rovnaké vyhľadávanie. Akonáhle sa vyskytne ďalšie malé číslo, presunie sa na ďalšie miesto v zozname hneď za prvým indexom a tento proces sa opakuje, až kým sa nezíska zoznam zoradenia. Týmto spôsobom sa triedenie vykonáva v programovacom jazyku C.
• Vo všetkých prístupoch k triedeniu zoznamu hrá pole veľmi dôležitú úlohu v programovacom jazyku C. V každom algoritme bolo pole použité na uloženie zoznamu prvkov, ktoré sa majú zoradiť. Napríklad pri triedení bublín sú prvky uložené v jednom poli a hodnoty v poli boli spracované tak, aby sa skonvertovali do zoznamu zoradených údajov.
• Pri výberovom usporiadaní sa rovnaké pole považovalo za dve polia, v ktorých sa prvé pole považuje za neobsadené, aby sa oznámili zoradené hodnoty, zatiaľ čo druhé pole obsahuje netriedený zoznam. Na účely triedenia sa pole používa veľmi často namiesto toho, aby sa hodnoty držali v jednotlivých premenných. Medzi všetkými algoritmami funguje rýchle zoradenie veľmi rýchlo, a preto sa nazýva rýchle zoradenie. V porovnaní s ostatnými triediacimi algoritmami to zaberie omnoho menej času.

Druhy triedenia v C

1. Zoradenie bubliniek

• Zoradenie bubliniek môže byť definované ako algoritmus triedenia, ktorý sa riadi prístupom nahradenia hodnoty v prvom indexe najmenšou hodnotou v poli a jej opakovania až do zoradenia zoznamu. Je to veľmi jednoduchý spôsob triedenia. Aby bolo možné zoradiť pole, musí byť hodnota priradená k poľu na začiatku pred začatím triedenia.
• Nižšie je uvedený program na usporiadanie poľa pomocou bublinového triedenia, kde boli hodnoty prevzaté od používateľa. Akonáhle je program zostavený a spustený, požiada používateľa o počet prvkov, ktoré chce zoradiť. Po zadaní čísla program požiada používateľa, aby poskytol hodnoty rovnocenné počtu, ktorý poskytol. Hodnoty sa uložia do poľa a budú sa ďalej spracúvať pomocou vnorených cyklov spolu s rozhodovaním pomocou „if“ na zoradenie poľa.
• Prvá najmenšia hodnota nájdená v poli bola presunutá do prvého indexu poľa a potom vyhľadávanie začne znova nájsť ďalšie najmenšie číslo. Akonáhle sa nájde najbližšie najmenšie číslo, nahradí hodnotu v druhom indexe a proces sa bude opakovať, až kým pole nebude pozostávať z triedeného zoznamu hodnôt.

kód

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

Užívateľ zadal vstup 5 3 60 14 1 2 645. Algoritmus bol aplikovaný na pole pozostávajúce z hodnôt spôsobom, ktorý poskytuje užívateľ, a po jeho spracovaní je výstup, ktorý sme dostali, 1 2 3 5 14 60 645,

Výkon:

2. Výber zoradenia

• Výberové usporiadanie môže byť definované ako ďalší algoritmus na triedenie zoznamu, v ktorom je pole rozdvojené do dvoch polí, kde sa predpokladá, že prvé pole je prázdne, zatiaľ čo druhé pole sa skladá z netriedeného zoznamu hodnôt. Program vyhľadá najmenšie hodnoty v druhom poli a keď sa nájde, presunie sa na začiatok prvého poľa, ktoré bolo prázdne. Tento prístup sa opakuje znova a najbližšie najmenšie hodnoty sa posunú na druhý index prvého poľa. Procesy sa budú opakovať, až kým sa druhé pole nevyprázdni.
• Nižšie uvedený program je kódovacia implementácia algoritmu výberu triedenia. Po úspešnom spustení programu sa od používateľa vyžaduje zadanie počtu hodnôt, ktoré sú ochotní zoradiť. Po získaní počtu program požiada používateľa, aby vložil hodnoty pre pole, ktoré sa má zoradiť. Hodnota sa potom spracuje pomocou vnoreného cyklu, aby sa čísla usporiadali. Na kontrole najmenšieho čísla sa tu použila aj kontrola stavu if.
• Procesy sa budú opakovať, až kým nebude prvý zoznam plný usporiadaného zoznamu. Medzitým si programy zachovajú svoje primárne zameranie, aby skontrolovali, či má druhé pole hodnotu a či sa zistí, že je pozitívny, program znova spustí triediaci algoritmus. Aj keď zoznam triedi jednoduchým spôsobom, v porovnaní s inými algoritmami to môže trvať trochu viac času. Výsledok, ktorý vygeneruje, bude nakoniec rovnaký ako pri ostatných triediacich algoritmoch.

kód
#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();
)

Na požiadavku na počet prvkov, ktoré sa majú triediť, užívateľ poskytol 6 na výstupe nižšie. Neskôr boli zadané hodnoty 25 65 36 86 96 45. Tieto hodnoty sú uložené v poli, o ktorom sa predpokladá, že bude rozdvojený na dve polia, z ktorých jedna bude prázdna na uloženie zoradeného zoznamu a druhá bude mať netriedený zoznam., Po spracovaní vstupu bol výsledok 25 36 45 65 86 96. Táto strata bola triedená podľa výberového usporiadania. Po presunutí všetkých šiestich hodnôt do prvého poľa v triedenej podobe sa druhé pole vyprázdni a algoritmus sa ukončí.

Výkon:

3. Rýchle zoradenie

• Quicksort sa dá definovať ako ďalší algoritmus na triedenie zoznamu, v ktorom je prístupom rozdelenie poľa z hľadiska väčších ako a menších ako hodnoty, až kým nie sú celé hodnoty rozdelené do individuálnych foriem. V tomto algoritme bola hodnota posledného indexu poľa vybraná ako pivot a všetky hodnoty menšie ako pivot boli posunuté do poľa, ktoré sa očakáva, že sa vyskytne vľavo od hodnoty a prvky, ktoré majú vyššiu hodnotu. potom sa čap posunie na správne pole. Opäť sa vyberie jeden pivot z novo vytvoreného poľa, ktoré malo hodnoty menšie ako posledná hodnota pivotu. Podobne sa hodnoty menšie ako nový pivot posunú do poľa, ktoré zostane, a hodnoty väčšie ako nový pivot sa posunú v pravom poli.
• Nižšie uvedený program predstavuje rýchlu implementáciu pomocou programovacieho jazyka C. Po spustení programu požiada používateľa o počet prvkov, ktoré chce zoradiť. Na základe počtu bude slučka for iterovať odhadované časy na prevzatie vstupu od používateľa. Vstup sa spracuje pomocou podmienok if spolu so slučkou for, aby sa vygeneroval triedený zoznam. Pole bude naďalej usporadúvať hodnoty pomocou hodnoty pivot, kým nebudú všetky hodnoty skontrolované na najmenšiu hodnotu.
• Zoradenie vykonané pomocou tohto algoritmu je v porovnaní s ostatnými algoritmami triedenia príliš rýchlejší, a preto sa nazýva rýchle zoradenie. Quicksort je jediný algoritmus, ktorý vedie k rozdeleniu poľa, kým sa všetky hodnoty neoddelia do jednotlivých polí. Potom sa pridajú alebo agregujú do jedného poľa, ktoré sa považuje za triedený zoznam.

kód:

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

V nižšie uvedenom výstupe používateľ potvrdil, že odošle 6 hodnôt a vytvorí zoznam zoradených údajov. Po zadaní počtu sú hodnoty poskytnuté používateľom 56, 35, 24, 86, 98, 2. Na tieto hodnoty sa použil skratka a vygeneroval sa triedený zoznam, ktorý má hodnotu 2, 24, 35, 56, 86, 98.

Výkon:

4. Zlúčiť zoradenie

• Zlúčiť zoraďovanie možno definovať ako ďalší zoraďovací algoritmus, ktorý vykonáva zoraďovanie oddeľovaním poľa do posledného času, keď sa zmení na individuálnu hodnotu, a potom ich agreguje takým spôsobom, aby sa mohol zmeniť na usporiadané pole.
• Proces v porovnaní s ostatnými konkurenčnými algoritmami zaberie trochu času, ale v porovnaní s ostatnými je považovaný za dosť efektívny. Pokiaľ ide o triedenie veľkého zoznamu, tento algoritmus funguje veľmi dobre, a preto sa uprednostňuje pri vývoji aplikácie, ktorá musí spracovať veľký zoznam.

kód:

#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);
)
Pri spustení vyššie uvedeného kódu najprv požiada používateľa, aby poskytol počet prvkov, ktoré chce zoradiť. Po predložení čísla budú musieť poskytnúť hodnoty rovnakého počtu, ktoré pôvodne poskytli. Po zadaní hodnôt algoritmus tieto hodnoty uchová v poli a spracuje ho tak, aby transformoval pole do zoradeného poľa. Po zoradení poľa vo vzostupnom poradí sa používateľovi zobrazí výstup.

Výkon:

5. Halda

• Zoradenie haldy možno definovať ako triediaci algoritmus, ktorý funguje vyhľadaním maximálneho prvku v zozname a umiestnením na posledný. Algoritmus vykonáva činnosť rekurzívne, kým sa pole nezoradí vzostupne.
• Je veľmi čas, aby ste si vybrali maximálnu hodnotu a presunuli ju na poslednú, a preto sa pri triedení veľkého zoznamu považuje za menej efektívny prístup k triedeniu. Funguje to však so zoznamom, ktorý má obmedzený počet hodnôt. Nasleduje implementácia tohto algoritmu v programovacom jazyku C spolu s výstupom.

kód:

#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;
)
)
)
Fungovanie tohto algoritmu je rovnaké ako pri iných triediacich algoritmoch, pretože tiež triedi zoznam vzostupne. Po spustení vyššie uvedeného kódu musí užívateľ odoslať počet hodnôt, ktoré bude triediť. Po zadaní hodnôt ich kód spracuje, aby premenil pole na zoradené. Výstup sa nakoniec zobrazí a je možné pozorovať, že hodnoty, ktoré zadal užívateľ, boli zoradené vzostupne.

Výkon:

6. Zoradenie vloženia

• Zoradenie vloženia možno definovať ako triediaci algoritmus, ktorý pracuje tak, že posúva minimálnu hodnotu na začiatku zoznamu po jednom. Toto je veľmi menej efektívny algoritmus triedenia a nie je vhodný na vysporiadanie sa s veľkým zoznamom.
• Tento prístup triedenia algoritmu funguje veľmi pomaly a zvyčajne sa v žiadnej z aplikácií uprednostňuje. Môže to fungovať dobre so zoznamom, ktorý obsahuje veľmi málo prvkov. Pre aplikácie, ktoré majú požiadavku spracovať niekoľko hodnôt, môžu tento algoritmus využiť.

kód:

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

Po spustení programu bude musieť užívateľ zadať počet hodnôt, ktoré potrebuje zoradiť. Potom sa hodnoty zadané používateľom uložia do poľa. Potom prechádzajú spracovaním a pomocou kontroly slučky a stavu sa minimálna hodnota presunie na začiatok pri každej rekurzii a nakoniec vygeneruje zoradené pole. Hodnoty sa používateľovi zobrazia na konci programu.

Výkon :

záver

Algoritmus triedenia sa používa na generovanie zoradeného zoznamu, čo je normálny zoznam, v ktorom sú všetky hodnoty triedené konkrétnym spôsobom. Zoznam sa v skutočnej aplikácii používa veľmi často na to, aby priniesol niektoré funkcie. V tomto článku sme sa venovali triedeniu bubliniek, triedeniu výberu a rýchlemu triedeniu, zatiaľ čo existuje niekoľko ďalších algoritmov, ako je napríklad zlúčenie triedenia, ktoré sa dajú využiť na vytvorenie zoradeného zoznamu. Medzi všetkými algoritmami triedenia pracuje quicksort veľmi rýchlo a pomáha triediť zoznam veľmi rýchlo. Tu napísané programy slúžia na implementáciu týchto triediacich algoritmov pomocou programovacieho jazyka C. Ak ste ochotní implementovať to isté v iných programovacích jazykoch, môžete použiť rovnakú logiku a jediné, čo sa môže líšiť, môže byť syntax a kľúčové slová.

Odporúčaný článok

Toto bol sprievodca triedením v C. Tu diskutujeme o úvode do triedenia v C a rôznych druhoch triedenia spolu so vzorovým kódom. Viac informácií nájdete aj v ďalších navrhovaných článkoch -

1. Vzory v programovaní C
2. Palindróm v programe C
3. Zlúčiť zoradenie v jazyku Java
4. Úvod do triedenia v R
5. Úvod do triedenia v C ++
6. Prehľad triedenia v PHP
7. Halda Zoradiť v Pythone
8. Funkcia triedenia v Pythone s príkladmi