Třídění v C - Různé typy třídění spolu s příkladem

• Úvod do třídění v C

Úvod do třídění v C

V aplikaci cítí vývojáři nutnost třídění dat, aby mohli přinést určitou funkčnost. Existuje několik přístupů k třídění dat a jsou počítána do třídění podle nomenklatury. Třídění lze definovat jako způsob uspořádání dat konkrétním způsobem, který následuje po určitém pořadí. Zde v této sekci se budeme učit o třídění pomocí programovacího jazyka C. Existuje několik typů třídění, například třídění bublin, slučování, třídění výběru, řazení a podobně. Provedeme skutečné kódování pro metody třídění, které se v aplikaci používají velmi často. Kódy vám budou k dispozici v textovém formátu, abyste mohli snadno najít použití tohoto kódu, zatímco výstup bude zobrazen na snímku obrazovky, abyste získali přehled o skutečném výstupu, který přichází po spuštění programu.

Jak se třídění provádí v C?

• Třídění lze provádět různými způsoby na základě třídicího algoritmu. V programovacím jazyce C máme několik přístupů k třídění seznamu. Termín třídění uvádí uspořádání dat konkrétním způsobem obvykle ve vzestupném pořadí. Přestože způsob třídění dat je ve všech třídicích algoritmech odlišný, výsledek všech z nich je stejný.
• Program při třídění obvykle hledá minimální počet a přesune toto číslo na začátek seznamu a opakuje stejná vyhledávání. Jakmile se objeví další malé číslo, je přesunuto na další místo v seznamu hned za prvním indexem a tento proces se opakuje, dokud není získán seznam řazení. Tímto způsobem se třídění provádí v programovacím jazyce C.
• Ve všech přístupech k třídění seznamu hraje pole velmi důležitou roli v programovacím jazyce C. V každém algoritmu bylo pole použito k uložení seznamu prvků, které mají být seřazeny. Například při třídění bublin jsou prvky uloženy v jediném poli a hodnoty v poli byly zpracovány tak, aby byly převedeny do seznamu tříděných dat.
• Ve výběrovém řazení bylo stejné pole považováno za dvě pole, kde je první pole považováno za prázdné, aby bylo možné sdělit seřazeným hodnotám, zatímco druhé pole obsahuje netříděný seznam. K tomu, aby sloužil účelu třídění, se pole používá často místo toho, aby hodnoty držel v jednotlivých proměnných. Ze všech algoritmů funguje rychlé řazení velmi rychle, a proto se nazývá rychlé řazení. Ve srovnání s jinými třídicími algoritmy to zabere mnohem méně času.

Druhy třídění v C

1. Řazení bublin

• Řazení bublin lze definovat jako algoritmus třídění, který sleduje přístup nahrazení hodnoty v prvním indexu nejmenší hodnotou v poli a opakování opakuje, dokud není seznam setříděn. Jedná se o velmi jednoduchý způsob řazení. Tímto způsobem pro seřazení pole musí být hodnota přiřazena k poli na začátku před zahájením třídění.
• Níže je uveden program pro seřazení pole pomocí bublinového třídění, kde byly hodnoty převzaty od uživatele. Jakmile je program zkompilován a spuštěn, požádá uživatele o počet prvků, které chtějí seřadit. Jakmile je číslo poskytnuto, program požádá uživatele, aby poskytl hodnoty ekvivalentní počtu, který poskytl. Hodnoty budou uloženy do pole a budou dále zpracovávány pomocí vnořené smyčky spolu s rozhodováním pomocí „if“, aby se pole uspořádalo.
• První nejmenší hodnota nalezená v poli byla přesunuta do prvního indexu pole a poté hledání začne znovu hledat další nejmenší číslo. Jakmile je nalezeno další nejmenší číslo, nahradí hodnotu ve druhém indexu a proces se bude opakovat, dokud se pole nebude skládat z seřazeného seznamu hodnot.

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živatel zadal vstup 5 3 60 14 1 2 645. Algoritmus byl použit na pole sestávající z hodnot způsobem, který poskytuje uživatel, a po zpracování je výstup, který jsme obdrželi, 1 2 3 5 14 60 645 .

Výstup:

2. Výběr řazení

• Výběrové řazení může být definováno jako další algoritmus pro třídění seznamu, ve kterém je pole rozdvojeno do dvou polí, kde má být první pole prázdné, zatímco druhé pole sestává z netříděného seznamu hodnot. Program vyhledá nejmenší hodnoty ve druhém poli a když je nalezena, byla přesunuta na začátek prvního pole, které bylo prázdné. Tento přístup se opakuje znovu a další nejmenší hodnoty se posunou na druhý index prvního pole. Procesy se budou opakovat, dokud se druhé pole nevyprázdní.
• Níže uvedený program je kódovací implementace algoritmu výběru řazení. Jakmile bude program úspěšně spuštěn, požádá uživatele o zadání počtu hodnot, které jsou ochotni seřadit. Jakmile je počet získán, program požádá uživatele o zadání hodnot pro pole, které má být tříděno. Hodnota je poté zpracována pomocí vnořených cyklů, aby se čísla uspořádala. Zde byla také zahrnuta kontrola stavu if, aby se zkontrolovalo nejmenší číslo.
• Procesy se budou opakovat, dokud nebude první seznam plný seřazeného seznamu. Mezitím si programy zachovají své primární zaměření, aby zkontrolovaly, zda má druhé pole hodnotu, a pokud se zjistí, že je pozitivní, program znovu spustí třídicí algoritmus. Ačkoli seznam třídí snadným způsobem, ve srovnání s jinými algoritmy to může trvat trochu více času. Nakonec však bude výsledek stejný jako u ostatních třídicích algoritmů.

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 žádost o počet prvků, které musí být tříděny, uživatel poskytl 6 v níže uvedeném výstupu. Později jsou zadané hodnoty 25 65 36 86 96 45. Tyto hodnoty jsou uloženy v poli, u kterého se očekává, že bude rozdvojeno do dvou polí, z nichž jedna bude prázdná pro uložení tříděného seznamu a druhá bude mít netříděný seznam. . Po zpracování vstupu byl výsledek 25 36 45 65 86 96. Ztráta byla tříděna pomocí třídění výběru. Po přesunutí všech šesti hodnot do prvního pole v seřazené podobě bude druhé pole prázdné a algoritmus bude ukončen.

Výstup:

3. Rychlé řazení

• Quicksort lze definovat jako další algoritmus pro třídění seznamu, ve kterém má přístup rozdělit matici z hlediska větších než a nižších než hodnoty, dokud se celé hodnoty nerozdělí, pokud jsou rozděleny do jednotlivých forem. V tomto algoritmu byla vybrána hodnota posledního indexu pole jako pivot a všechny hodnoty menší než pivot byly přesunuty do pole, u kterého se očekává, že se objeví vlevo od hodnoty a prvky mající vyšší hodnotu. než je pivot posunut do správného pole. Z nově vytvořeného pole, které mělo hodnoty menší než poslední hodnota pivotu, je opět vybrán jeden pivot. Podobně budou hodnoty menší než nový pivot posunuty do pole, které zůstane, a hodnoty více než nový pivot budou posunuty v pravém poli.
• Níže uvedený program je implementace rychlého třídění pomocí programovacího jazyka C. Jakmile je program spuštěn, požádá uživatele o počet prvků, které chtějí seřadit. Na základě počtu bude smyčka for iterovat odhadované časy pro převzetí vstupu od uživatele. Vstup bude zpracován pomocí podmínek if spolu se smyčkou for, aby se vygeneroval seřazený seznam. Pole bude i nadále uspořádávat hodnoty pomocí hodnoty pivot, dokud nebudou všechny hodnoty zkontrolovány na nejmenší hodnotu.
• Třídění provedené pomocí tohoto algoritmu je v porovnání s ostatními algoritmy třídění příliš rychlejší, a proto bylo pojmenováno rychlé řazení. Quicksort je jediný algoritmus, který vede k rozdělení pole, dokud nejsou všechny hodnoty rozděleny do jednotlivých polí. Poté budou přidány nebo agregovány do jednoho pole, které je považováno za seřazený seznam.

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 níže uvedeném výstupu uživatel potvrdil, že odešle 6 hodnot a vytvoří seznam tříděných dat. Po zadání počtu jsou hodnoty poskytnuté uživatelem 56, 35, 24, 86, 98, 2. Na tyto hodnoty byl použit quicksort a byl vygenerován tříděný seznam, který má hodnotu 2, 24, 35, 56, 86, 98.

Výstup:

4. Sloučit řazení

• Sloučené řazení může být definováno jako jiný třídicí algoritmus, který provádí třídění segregací pole do posledního, když se změní na individuální hodnotu, a pak je agreguje tak, aby se mohl změnit na tříděné pole.
• Proces ve srovnání s ostatními konkurenčními algoritmy zabere trochu času, ale ve srovnání s ostatními je považován za docela účinný. Pokud jde o třídění velkého seznamu, tento algoritmus funguje velmi dobře, a proto je upřednostňován při vývoji aplikace, která musí velký seznam zpracovávat.

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);
)
Při spuštění výše uvedeného kódu nejprve požádá uživatele, aby poskytl počet prvků, které chtějí seřadit. Po zadání čísla budou muset poskytnout hodnoty stejného počtu, které původně poskytly. Jakmile jsou hodnoty odeslány, algoritmus tyto hodnoty v poli uloží a zpracuje, aby transformoval pole do seřazeného pole. Po seřazení pole ve vzestupném pořadí se uživateli zobrazí výstup.

Výstup:

5. Heapsort

• Třídění haldy lze definovat jako algoritmus třídění, který funguje tak, že prohledá maximum prvku v seznamu a umístí jej na poslední. Algoritmus provede akci rekurzivně, dokud se pole nezařazí vzestupně.
• Je velmi čas, aby proces zvolil maximální hodnotu a přesunul ji na poslední, a proto se považuje za méně účinný přístup k třídění, pokud jde o třídění velkého seznamu. Funguje to však dobře se seznamem, který má omezený počet hodnot. Níže je implementace tohoto algoritmu v programovacím jazyce C společně s výstupem.

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;
)
)
)
Fungování tohoto algoritmu je stejné jako u jiných třídicích algoritmů, protože také třídí seznam vzestupně. Při spuštění výše popsaného kódu musí uživatel zadat počet hodnot, které budou třídit. Jakmile jsou hodnoty odeslány, kód je zpracuje, aby se pole změnilo na tříděné. Výstup bude nakonec zobrazen a lze pozorovat, že hodnoty, které byly zadány uživatelem, byly seřazeny vzestupně.

Výstup:

6. Třídění vložení

• Třídění vložení lze definovat jako třídicí algoritmus, který pracuje pohybem minimální hodnoty na začátku seznamu po jednom. Toto je velmi méně efektivní algoritmus třídění a není vhodný pro řešení velkého seznamu.
• Tento přístup třídění algoritmu pracuje velmi pomalu a obvykle není preferován v žádné z aplikací. Může to dobře fungovat se seznamem, který obsahuje velmi málo prvků. U aplikací, které mají požadavek na zpracování několika čísel, může tento algoritmus využít.

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

Když se program spustí, bude uživatel muset zadat počet hodnot, které musí seřadit. Poté budou hodnoty zadané uživatelem uloženy do pole. Poté se podrobí zpracování a pomocí kontroly smyček a podmínek se minimální hodnota přesune na začátek při každé rekurzi a skončí generováním seřazeného pole. Hodnoty se uživateli zobrazí na konci programu.

Výstup :

Závěr

Algoritmus třídění se používá k vytvoření tříděného seznamu, což je normální seznam, kde jsou všechny hodnoty tříděny konkrétním způsobem. Seznam byl ve skutečné aplikaci používán velmi často, aby přinesl některé funkce. V tomto článku jsme se zabývali tříděním bublin, tříděním výběrů a quicksortem, zatímco existuje několik dalších algoritmů, jako je například sloučení třídění, které lze využít k vytvoření tříděného seznamu. Mezi všemi třídicími algoritmy pracuje quicksort velmi rychle a pomáhá třídit seznam velmi rychle. Zde napsané programy v zásadě implementují tyto třídicí algoritmy pomocí programovacího jazyka C. Pokud jste ochotni implementovat totéž v jiných programovacích jazycích, můžete použít stejnou logiku a jediná věc, která se může lišit, může být syntaxe a klíčová slova.

Doporučený článek

Toto byl průvodce tříděním v C. Zde diskutujeme úvod do třídění v C a různé typy třídění spolu se ukázkovým kódem. Další informace naleznete také v dalších navrhovaných článcích -

1. Vzory v programování C
2. Palindrom v programu C
3. Sloučit řazení v Javě
4. Úvod do třídění v R
5. Úvod do třídění v C ++
6. Přehled třídění v PHP
7. Haldy Seřadit v Pythonu
8. Funkce třídění v Pythonu s příklady