Razvrščanje v C - Različne vrste razvrščanja in primer

• Uvod v razvrščanje v C

Uvod v razvrščanje v C

V aplikaciji razvijalci čutijo potrebo po razvrščanju podatkov, da bi omogočili določeno funkcionalnost. Obstaja več pristopov za razvrščanje podatkov in jih štejemo v razvrstitev po nomenklaturi. Razvrščanje lahko opredelimo kot način urejanja podatkov na poseben način, ki sledi določenemu vrstnem redu. Tu v tem razdelku bomo spoznali razvrščanje s programskim jezikom C. Obstaja več vrst razvrščanja, kot so mehurčki, sortiranje, sortiranje, sortiranje in tako naprej. Naredili bomo dejansko kodiranje metod razvrščanja, ki se v aplikaciji uporabljajo zelo pogosto. Kode vam bodo na voljo v besedilni obliki, tako da boste lahko preprosto uporabili to kodo, medtem ko bo izhod prikazan na posnetku zaslona in vam omogočil vpogled v dejanski rezultat, ki pride po zagonu programa.

Kako se sortiranje izvaja v C?

• Razvrščanje lahko izvedemo na različne načine na podlagi algoritma razvrščanja. V programskem jeziku C imamo več pristopov za razvrščanje seznama. Izraz razvrščanje navaja urejanje podatkov na določen način, običajno v naraščajočem vrstnem redu. Čeprav je način razvrščanja podatkov v vseh algoritmih razvrščanja različen, je rezultat vseh enak.
• Običajno program pri razvrščanju poišče najmanjše število in ga premakne na začetek seznama ter ponovi ista iskanja. Ko se sreča drugo majhno število, se premakne na naslednji prostor na seznamu takoj po prvem indeksu in ta postopek se ponavlja, dokler ne dobimo seznama razvrščanja. Tako se razvrščanje izvaja v programskem jeziku C.
• V vseh pristopih k razvrščanju seznama ima matrika zelo pomembno vlogo v programskem jeziku C. V vsakem algoritmu je matrika uporabljena za shranjevanje seznama elementov, ki jih je treba razvrstiti. Na primer, v obliki mehurčkov so elementi shranjeni v enem samem nizu in vrednosti v matriki so obdelane, da jih pretvorijo v seznam razvrščenih podatkov.
• V izbirni razvrstitvi je enaka matrika obravnavana kot dva niza, pri čemer se prvi matrika šteje za prosti, da bi lahko povedal razvrščene vrednosti, medtem ko drugi matrika vsebuje neortirani seznam. Da bi služili namenu razvrščanja matrike, se zelo pogosto uporablja namesto zadrževanja vrednosti v posameznih spremenljivkah. Hitro razvrščanje med vsemi algoritmi deluje zelo hitro in je zato imenovano hitro razvrščanje. V primerjavi z drugimi algoritmi za razvrščanje traja veliko manj časa.

Vrste razvrščanja v C

1. Razporeditev mehurčkov

• Razporeditev mehurčkov je mogoče opredeliti kot algoritem razvrščanja, ki sledi pristopu nadomeščanja vrednosti v prvem indeksu z najmanjšo vrednostjo v matriki in ga ponavlja, dokler se seznam ne razvrsti. To je zelo preprost način razvrščanja. Na ta način razvrstite matriko, je treba v začetku dodeliti vrednost matriki, preden začnete razvrščati.
• Spodaj je program za razvrščanje matrike z uporabo mehurčkov, kjer so bile vrednosti odvzete od uporabnika. Ko je program sestavljen in se zažene, bo uporabnika vprašal za število elementov, ki jih želi razvrstiti. Ko je številka zagotovljena, program od uporabnika zahteva, da zagotovi vrednosti, enakovredne štetju, ki ga je navedel. Vrednosti bodo shranjene v matriki in bodo nadalje obdelane z uporabo ugnezdenih za zanko, skupaj z odločitvijo z uporabo "če", da bi razvrstili niz.
• Prva najmanjša vrednost, ki jo najdemo v matriki, je bila premaknjena v prvi indeks matrike, nato pa se iskanje začne znova, da bi našlo drugo najmanjše število. Ko je najdeno naslednje najmanjše število, nadomesti vrednost v drugem indeksu in postopek se ponavlja, dokler matrika ni sestavljena iz razvrščenega seznama vrednosti.

Koda

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

Uporabnik je predložil vhod 5 3 60 14 1 2 645. Algoritem je bil uporabljen na matriki, ki je sestavljena iz vrednosti na način, kot ga uporabnik zagotavlja, in ko je obdelal izhod, ki smo ga prejeli, je 1 2 3 5 14 60 645 .

Izhod:

2. Razvrstitev izbire

• Razvrstitveni izbor je lahko opredeljen kot drug algoritem za razvrščanje seznama, v katerem je matrika razčlenjena v dva niza, kjer naj bi bil prvi niz prazen, medtem ko je drugi niz sestavljen iz neortiziranega seznama vrednosti. Program poišče najmanjše vrednosti v drugem nizu in ko je vrednost najdena, se premakne na začetek prvega polja, ki je bil prazen. Pristop se znova ponovi in ​​naslednje najmanjše vrednosti bodo preusmerjene na drugi indeks prvega niza. Postopki se bodo ponavljali, dokler drugi niz ne postane prazen.
• Spodnji program je kodiranje izvedbe algoritma za izbiro. Ko program uspešno deluje, bo od uporabnika zahteval, da vnese število vrednosti, ki jih je pripravljen razvrstiti. Ko dobimo štetje, program od uporabnika zahteva, da vnese vrednosti za matriko, ki jo je treba razvrstiti. Vrednost se nato obdela z uporabo ugnezdenih za zanko, da bi razvrstili številke. Tu je bilo vključeno tudi preverjanje stanja, če želite preveriti najmanjše število.
• Postopki se bodo ponavljali, dokler ni na prvem seznamu razvrščenega seznama. Medtem se programi osredotočajo na preverjanje, ali ima drugi niz vrednost in če je pozitiven, program znova zažene algoritem sortiranja. Čeprav seznam razvršča na enostaven način, lahko traja malo več časa v primerjavi z drugimi algoritmi. Do konca pa bo rezultat, ki ga bo ustvaril, enak ostalim algoritmom za razvrščanje.

Koda
#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 vprašanje o številu elementov, ki jih je treba razvrstiti, je uporabnik v spodnjem izhodu navedel 6. Pozneje so bile vnesene vrednosti 25 65 36 86 96 45. Te vrednosti so shranjene v matriki, ki naj bi bila razčlenjena v dva niza, kjer bo eden prazen za shranjevanje razvrščenega seznama, drugi pa neortoriziran seznam . Po obdelavi vnosa je bil rezultat 25 36 45 65 86 96. To izgubo smo razvrstili z izbiro vrste. Ko bomo vseh šest vrednosti premaknili v prvo matriko v razvrščeni obliki, bo druga matrika postala prazna in algoritem zaključen.

Izhod:

3. Hitro razvrščanje

• Quicksort lahko definiramo kot drugi algoritem za razvrščanje seznama, v katerem je pristop razdeliti matriko na vrednosti, ki so večje od in manj od vrednosti, dokler se ne oblikujejo celotne vrednosti, če jih delimo na posameznike. V tem algoritmu je bila vrednost zadnjega indeksa matrike izbrana kot vrtišče in vse vrednosti, manjše od vrtenja, so premaknjene na matriko, ki naj bi se pojavljala na levi strani vrednosti in elemente z višjo vrednostjo kot se vrtišče premakne na desni niz. Spet je izbrano eno vrtišče iz novo oblikovanega niza, ki je imel vrednosti manjše od zadnje vrednosti vrtenja. Podobno se bodo vrednosti, manjše od novega vrtišča, premaknile v levi niz in vrednosti, ki so bolj kot nove, se bodo premaknile v desni niz.
• Spodnji program je izvedba quicksort z uporabo programskega jezika C. Ko se program zažene, bo uporabnika vprašal za število elementov, ki jih želi razvrstiti. Na podlagi števila bo zanka for ponovila predvidene čase, da bi uporabnik vložila vnos. Vhod bo obdelan s pogoji if, skupaj z zanko for, da se ustvari razvrščen seznam. Matrika bo nadaljevala z urejanjem vrednosti s pomočjo vrtilne vrednosti, dokler niso vse vrednosti preverjene za najmanjšo vrednost.
• Razvrščanje s tem algoritmom je prehitro v primerjavi z drugimi algoritmi za razvrščanje in zato je bilo imenovano hitro razvrščanje. Quicksort je edini algoritem, ki vodi k deljenju matrike, dokler se vse vrednosti ne ločijo v posamezne matrike. Nato bodo dodani ali združeni v enem samem nizu, ki velja za razvrščen seznam.

Koda:

#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 spodnjem izhodu je uporabnik potrdil, da bo predložil 6 vrednosti in oblikoval seznam razvrščenih podatkov. Po posredovanju štetja so vrednosti, ki jih zagotavlja uporabnik, 56, 35, 24, 86, 98, 2. Na te vrednosti je bil uporabljen quicksort in ustvarjen je razvrščen seznam, ki ima vrednost 2, 24, 35, 56, 86, 98.

Izhod:

4. Združi razvrstitev

• Razvrsti združevanje je mogoče opredeliti kot drug algoritem razvrščanja, ki izvaja sortiranje tako, da se matrika loči do zadnjega, ko se spremeni v posamezno vrednost, nato pa jih združi tako, da se lahko spremeni v razvrščeno matriko.
• Postopek v primerjavi z drugimi rivalskimi algoritmi porabi nekaj časa, vendar v primerjavi z drugimi velja za precej učinkovitega. Ko gre za razvrščanje velikega seznama, ta algoritem deluje zelo v redu in zato raje pri razvoju aplikacije, ki mora obdelati velik seznam.

Koda:

#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);
)
Ko se zgornja koda zažene, uporabnik najprej prosi, da navede število elementov, ki jih želi razvrstiti. Ko je število predloženo, bodo morali navesti enake vrednosti, ki so jih dali na začetku. Ko so vrednosti poslane, bo algoritem te vrednosti zadržal v matriki in jih obdelal, da bo matriko pretvoril v razvrščeno matriko. Po razvrstitvi matrike po naraščajočem vrstnem redu se uporabniku prikaže izhod.

Izhod:

5. Zmogljivost

• Razvrstitev v kopici je mogoče opredeliti kot algoritem razvrščanja, ki deluje tako, da išče največji element na seznamu in ga postavi na zadnjega. Algoritem izvede dejanje rekurzivno, dokler se matrika ne razvrsti po naraščajočem.
• Skrajni čas je, da izberete največjo vrednost in jo prestavite na zadnjo, zato velja za razvrščanje velikega seznama kot manj učinkovit način razvrščanja. Vendar pa deluje v redu s seznamom, ki ima omejeno število vrednosti. Spodaj je izvedba tega algoritma v programskem jeziku C skupaj z izhodom.

Koda:

#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;
)
)
)
Delovanje tega algoritma je enako kot pri drugih algoritmih za razvrščanje, saj tudi seznam razvršča v naraščajočem vrstnem redu. Ko teče zgoraj napisana koda, mora uporabnik predložiti število vrednosti, ki jih bo razvrščal. Ko bodo vrednosti poslane, jih bo koda obdelala, da bi matriko pretvorila v razvrščeno. Rezultat bo prikazan na koncu in opazimo, da so vrednosti, ki jih je uporabnik predložil, razvrščene po naraščajočem vrstnem redu.

Izhod:

6. Razvrstitev vstavka

• Razvrstitveni vložek je lahko opredeljen kot algoritem razvrščanja, ki deluje s premikanjem najmanjše vrednosti na začetku seznama po enega. To je zelo manj učinkovit algoritem za razvrščanje in ni primeren za obravnavo velikega seznama.
• Ta pristop razvrščanja algoritma deluje zelo počasi in običajno ni zaželen v nobeni od aplikacij. Dobro se lahko obnese s seznamom, ki vsebuje kar nekaj elementov. Za aplikacije, ki zahtevajo obdelavo nekaj številk vrednosti, lahko ta algoritem izkoristi.

Koda:

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

Ko se program zažene, bo moral uporabnik vnesti število vrednosti, ki jih mora razvrstiti. Nato bodo vrednosti, ki jih vnese uporabnik, shranjene v matriko. Nato bodo prešli v obdelavo in z uporabo za zanko in preverjanje stanja se najmanjša vrednost premakne na začetek v vsaki rekurziji in konča z ustvarjanjem razvrščenega niza. Vrednosti bodo uporabniku prikazane na koncu programa.

Izhod:

Zaključek

Algoritem razvrščanja se uporablja za ustvarjanje razvrščenega seznama, ki je običajen seznam, kjer so vse vrednosti razvrščene na določen način. Seznam je bil uporabljen zelo pogosto v dejanski aplikaciji, da bi prinesel nekatere funkcionalnosti. V tem članku smo zajeli razvrščanje mehurčkov, izbiro razvrščanja in hitro izbiro, medtem ko obstaja več drugih algoritmov, kot je razvrstitev združevanja, ki jih je mogoče uporabiti za ustvarjanje razvrščenega seznama. Quicksort med vsemi algoritmi za razvrščanje deluje zelo hitro in pomaga pri razvrščanju seznama zelo hitro. Tukaj napisani programi so v bistvu za izvajanje teh algoritmov za razvrščanje s programskim jezikom C. Če želite pripraviti isto v drugih programskih jezikih, lahko uporabite isto logiko in edino, kar se lahko razlikuje, so sintaksa in ključne besede.

Priporočeni članek

To je vodnik za razvrščanje v C. Tukaj razpravljamo o uvodu v razvrščanje v C in različnih vrstah razvrščanja skupaj z vzorčno kodo. Če želite izvedeti več, lahko preberete tudi druge naše predlagane članke -

1. Vzorci v C programiranju
2. Palindrome v programu C
3. Združi razvrščanje v Javi
4. Uvod v razvrščanje v R
5. Uvod v razvrščanje v C ++
6. Pregled razvrščanja v PHP
7. Razvrstite v Python
8. Funkcija razvrščanja v Pythonu s primeri