Rendezés C - Különböző típusú rendezés a példával együtt

• Bevezetés a válogatásba C

Bevezetés a válogatásba C

Az alkalmazásban a fejlesztők érzik a vágyat az adatok rendezésére annak érdekében, hogy lehetővé tegyék bizonyos funkciók bevezetését. Az adatok rendezéséhez számos megközelítés létezik, és azokat a nómenklatúra szerint sorolják. A szortírozás az adatok meghatározott módon, bizonyos sorrend szerint történő rendezésének módjaként határozható meg. Itt, ebben a szakaszban, megtanuljuk a C programozási nyelv használatával történő válogatást. Különböző típusú rendezés létezik, például a buborék rendezése, az egyesítés, a kiválasztás, a beszúrás és a továbbiak. Az alkalmazásban nagyon gyakran használt válogató módszerek tényleges kódolását fogjuk elvégezni. A kódok szöveges formátumban lesznek elérhetők, így könnyű használni ezt a kódot, miközben a kimenet megjelenik a képernyőképen, hogy betekintést nyújtson a program futtatása utáni tényleges kimenetbe.

Hogyan történik a szortírozás C-ben?

• A rendezés különféle módon végezhető el a rendezési algoritmus alapján. A C programozási nyelvben számos módszerünk van a lista rendezésére. A szortírozás kifejezés az adatok meghatározott módon történő rendezését jelenti, általában növekvő sorrendben. Bár az adatok rendezésének módja az összes rendezési algoritmusban különbözik, mindegyik eredménye azonos.
• Általában a rendezés során a program megkeresi a minimális számot, és a szám elejét a lista elejére mozgatja, és ugyanazokat a kereséseket megismétli. Amint a másik kicsi számot észleltük, a lista a következő helyre kerül az első index után, és ezt a folyamatot mindaddig ismételjük, amíg a rendezési lista meg nem készül. Így történik a válogatás a C programozási nyelven.
• A lista rendezésének minden megközelítésében a tömb nagyon fontos szerepet játszik a C programozási nyelvben. Minden algoritmusban a tömböt használták a rendezendő elemek listájának tárolására. Például, buborékos rendezésben az elemeket egyetlen tömbben tárolják, és a tömbben lévő értékeket feldolgozták, hogy átalakítsák őket a rendezett adatok listájává.
• A kiválasztási sorrendben ugyanazt a tömböt két tömbként kezelték, ahol az első tömböt üresnek tekintik a rendezett értékek megadása érdekében, míg a második tömb a nem válogatott listát tartalmazza. A tömb rendezése céljából gyakran használják a tömböt az egyes változókon tárolt értékek helyett. Az összes algoritmus közül a gyors rendezés nagyon gyorsan működik, és ezért a gyors rendezés elnevezést kapja. Sokkal kevesebb időt vesz igénybe, mint a többi rendezési algoritmust.

Rendezés típusai C-ben

1. Bubble Sort

• A buborékrendezés meghatározható azon rendezési algoritmusként, amely követi azt a megközelítést, hogy az első indexben szereplő értéket a tömb legkisebb értékére cserélik, és addig ismételjük, amíg a lista rendezésre nem kerül. A válogatás nagyon egyszerű módja. A tömb rendezésének ilyen módon a rendezés megkezdése előtt az értéket hozzá kell rendelni a tömbhöz.
• Az alábbiakban bemutatjuk a tömb rendezését buborékrendezés segítségével, ahol az értékeket a felhasználótól vettük. A program összeállítása és futtatása után megkérdezi a felhasználót, hogy hány elemet kíván rendezni. Miután megadta a számot, a program felkéri a felhasználót, hogy adjon meg értékeket, amelyek megegyeznek a megadott számmal. Az értékeket a tömbben tárolják és tovább dolgozzák fel a hurokba ágyazott beágyazással, valamint a „if” használatával történő döntéshozatallal a tömb rendezése céljából.
• A tömbben található első legkisebb érték átkerült a tömb első indexébe, majd a keresés újraindul a másik legkisebb szám megtalálásához. Miután megtalálták a következő legkisebb számot, helyettesíti a második indexben szereplő értéket, és a folyamat addig ismétlődik, amíg a tömb rendezett értéklistából áll.

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

A felhasználó beadta az 5 3 60 14 1 2 645 bemenetet. Az algoritmust az értékeket tartalmazó tömbre alkalmaztuk a felhasználó által megadott módon, és feldolgozása után a kapott kimenet 1 2 3 5 14 60 645 .

Kimenet:

2. Kiválasztás Rendezés

• A kiválasztási rendezés meghatározható egy másik algoritmusként annak a listanak a szortírozására, amelyben a tömb két tömbre bontódik, ahol az első tömbnek feltételezhetően üresnek kell lennie, míg a második tömbnek a válogatott értéklistát kell tartalmaznia. A program a második tömb legkisebb értékét keresi, és amikor az érték megtalálható, az első üres tömb elejére kerül. A megközelítést ismét megismételjük, és a következő legkisebb értékek az első tömb második indexére kerülnek. A folyamatok addig ismétlődnek, amíg a második tömb kiürül.
• Az alábbi program a kiválasztási rendezési algoritmus kódolási megvalósítását tartalmazza. Miután a program sikeresen fut, kérni fogja a felhasználót, hogy adja meg az értékek számát, amelyeket hajlandó rendezni. A számlálás megszerzése után a program felkéri a felhasználót, hogy adja meg a rendezendõ tömb értékeit. Az értéket ezután beágyazott hurok segítségével dolgozzuk fel a számok rendezése érdekében. Ha a feltétel ellenőrzését is elvégezték, itt a legkisebb szám ellenőrzésére is sor került.
• A folyamatokat addig ismételjük, amíg az első lista megtelik a rendezett listával. Eközben a programok továbbra is elsődlegesen ellenőrzik annak ellenőrzését, hogy a második tömbnek van-e értéke, és ha pozitívnak találják, a program újra futtatja a rendezési algoritmust. Annak ellenére, hogy egyszerűen rendezi a listát, kissé több időt vehet igénybe a többi algoritmushoz képest. De a végén az általa generált eredmény megegyezik a többi rendezési algoritmussal.

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

Amikor megkérdezi a rendezendő elemek számát, a felhasználó megadta az alábbi kimenetet. Később a bevitt értékek 25 65 36 86 96 45. Ezek az értékek a tömbben kerülnek tárolásra, amely várhatóan két tömbre oszlik, ahol az egyik üres lesz a rendezett lista tárolására, a másik pedig a nem válogatott listára. . A bemenetek feldolgozása után az eredmény 25 36 45 65 86 96 volt. A veszteséget a kiválasztási rendezéssel rendeztük. Miután mind a hat érték átkerült az első tömbbe rendezett formában, a második tömb üres lesz, és az algoritmus megszűnik.

Kimenet:

3. Gyors rendezés

• A Quicksort meghatározható a lista azon osztályozásának másik algoritmusaként, amelyben a megközelítés a tömb nagyobb és kevesebb értékre osztása, amíg a teljes értékek nem oszlanak meg az alakokban. Ebben az algoritmusban a tömb utolsó indexének értékét választottuk pivotként, és a pivotnál kisebb minden értéket elmozdítottuk a tömbbe, amely várhatóan az érték bal oldalán fordul elő, és a nagyobb értékű elemek mint a forgatókar elmozdul a jobb tömbbe. Az újonnan kialakított tömbből ismét egy pivot választunk, amelynek értékei alacsonyabbak voltak, mint az utolsó pivot érték. Hasonlóképpen, az új pivotnál kisebb értékek a bal oldali tömbbe kerülnek, és az új pivotnál nagyobb értékek a jobb tömbbe kerülnek.
• Az alábbi program a gyorsprogramozás megvalósítását használja a C programozási nyelv használatával. Amint a program fut, megkérdezi a felhasználót, hogy hány elemet kíván rendezni. A számlálás alapján a for hurok megismétli a becsült időket, hogy a felhasználótól megkapja a bemenetet. A bemenetet az if feltételek és a for hurok együttes felhasználásával dolgozzuk fel, hogy rendezett listát hozzunk létre. A tömb addig rendezi az értékeket a pivot érték felhasználásával, amíg az összes érték meg nem ellenőrzi a legkisebb értéket.
• Az ezen algoritmus segítségével végzett rendezés túlságosan gyorsabb a többi rendezési algoritmushoz képest, ezért nevezték el gyors rendezésnek. A Quicksort az egyetlen algoritmus, amely a tömb felosztásához vezet mindaddig, amíg az összes értéket el nem választják az egyes tömbökre. Ezeket majd hozzáadják vagy aggregálják egyetlen tömbben, amelyet a rendezett listanak tekintnek.

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

Az alábbi kiadásban a felhasználó megerősítette, hogy 6 értéket fog küldeni, és a rendezett adatok listáját képezi. A számlálás után a felhasználó által megadott értékek 56, 35, 24, 86, 98, 2. Ezekre az értékekre a gyorsmenüt alkalmazták, és elkészült a 2, 24, 35, 56 értékű válogatott lista., 86, 98.

Kimenet:

4. Rendezés egyesítése

• Az egyesítés rendezése meghatározható egy másik válogatási algoritmusként, amely a szétválogatást úgy hajtja végre, hogy a tömböt elkülöníti, amíg az egyéni értékré válik, majd aggregálja azokat, oly módon, hogy válogatott tömbré váljon.
• A folyamat kissé sok időt vesz igénybe a többi rivális algoritmushoz képest, ám másokhoz képest elég hatékonynak tekintik. Ha nagy listát válogatunk, ez az algoritmus nagyon jól működik, és ezért előnyben részesíti a nagy listát feldolgozó alkalmazás fejlesztésében.

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);
)
A fenti kód futtatásakor először a felhasználót kéri, hogy adja meg a rendezni kívánt elemek számát. A szám benyújtása után meg kell adniuk a kezdetben megadott azonos számú értékeket. Az értékek beküldése után az algoritmus megtartja ezeket az értékeket a tömbben, és feldolgozza azt a tömb válogatott tömbbé történő átalakításához. Miután a tömb növekvő sorrendbe került, a kimenet megjelenik a felhasználó számára.

Kimenet:

5. Heapsort

• A halomfajta osztályozási algoritmusként definiálható, amely úgy működik, hogy megkeresi a maximális elemet a listában, és az utoljára helyezi. Az algoritmus a műveletet rekurzív módon hajtja végre, amíg a tömb növekvő sorrendbe nem kerül.
• Nagyon sok idő telik el a folyamat kiválasztásakor, amikor a maximális értéket kiválasztják, és az utoljára áthelyezik, ezért kevésbé hatékony válogatási megközelítésnek tekintik a nagy lista rendezésekor. Ugyanakkor jól működik a korlátozott számú értékű listával. Az alábbiakban bemutatjuk ennek az algoritmusnak a C programozási nyelvén történő megvalósítását, a kimenettel együtt.

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;
)
)
)
Ezen algoritmus működése megegyezik a többi rendezési algoritmus működésével, mivel szintén növekvő sorrendben rendezi a listát. Amikor a fent leírt kód fut, a felhasználónak be kell nyújtania az osztályozandó értékek számát. Az értékek beküldése után a kód feldolgozza azokat, hogy a tömb rendezetté váljon. A kimenetet végül megmutatjuk, és megfigyelhető, hogy a felhasználó által megadott értékek növekvő sorrendben vannak rendezve.

Kimenet:

6. Beszúrás rendezése

• A beszúrási rendezés meghatározható olyan rendezési algoritmusként, amely úgy működik, hogy egyenként mozgatja a minimális értéket a lista elején. Ez egy nagyon kevésbé hatékony rendezési algoritmus, amelyet nem találtak megfelelőnek a nagy lista kezelésére.
• Az algoritmus rendezésének ez a megközelítése nagyon lassan működik, és általában egyik alkalmazásban sem előnyös. Jól működik a listával, amelyben nagyon kevés elem van. Azon alkalmazások esetében, amelyekben néhány érték feldolgozására van szükség, felhasználhatják ezt az algoritmust.

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

A program futásakor a felhasználónak be kell írnia a rendezéshez szükséges értékeket. Ezután a felhasználó által bevitt értékek a tömbbe kerülnek. Ezután feldolgozás alatt állnak, és a hurok- és állapot-ellenőrzés használatával a minimális értéket minden rekurzáció elején mozgatják, és egy rendezett tömb létrehozásával végzik. Az értékek a program végén jelennek meg a felhasználó számára.

Kimenet :

Következtetés

A rendezési algoritmust egy válogatott lista létrehozására használják, amely egy normál lista, ahol az összes értéket meghatározott módon rendezik. A listát nagyon gyakran használják a tényleges alkalmazásban, hogy bizonyos funkciókat előállítsanak. Ebben a cikkben a buborékfajtát, a szelekciós rendezést és a gyorsfajta sort, de számos más algoritmus is létezik, például az egyesítés rendezése, amelyek szintén kihasználhatók egy rendezett lista létrehozására. Az összes rendezési algoritmus közül a quicksort nagyon gyorsan működik, és segít a lista gyors rendezésében. Az itt írt programok alapvetően ezeknek a szortírozó algoritmusoknak a C programozási nyelv használatával történő megvalósítására szolgálnak. Ha hajlandó végrehajtani ugyanazt más programozási nyelveken, akkor ugyanazt a logikát használhatja, és az egyetlen dolog, amely változhat, lehet a szintaxis és a kulcsszavak.

Ajánlott cikk

Ez egy útmutató a C típusú válogatáshoz. Itt tárgyalunk egy bevezetést a C típusú szortírozásról és a különféle típusú válogatást a mintakóddal együtt. A további javasolt cikkeken keresztül további információkat is megtudhat -

1. Minta a C programozásban
2. Palindrome a C programban
3. Merge Sort of Java
4. Bevezetés a válogatásba R
5. Bevezetés a C ++ szerinti rendezésbe
6. A válogatás áttekintése a PHP-ben
7. Halom Rendezés Pythonban
8. Rendezési funkció Python-ban példákkal