Uvod u razvrstavanje u C
U aplikaciji programeri osjećaju potrebu sortiranja podataka kako bi im se donijela određena funkcionalnost. Postoji nekoliko pristupa sortiranju podataka i oni se računaju razvrstavanjem prema nomenklaturi. Razvrstavanje se može definirati kao metoda aranžiranja podataka na poseban način koji slijedi neki redoslijed. Ovdje u ovom odjeljku naučit ćemo sortiranje pomoću programskog jezika C. Postoji nekoliko vrsta sortiranja poput mjehurića, sortiranja, sortiranja, sortiranja i tako dalje. Učinit ćemo stvarno kodiranje metoda sortiranja koje se vrlo često koriste u aplikaciji. Kodovi će vam biti dostupni u tekstualnom formatu tako da možete lako pronaći taj kôd dok će se izlaz prikazati na snimci zaslona kako biste dobili uvid u stvarni izlaz koji dolazi nakon pokretanja programa.
Kako se vrši sortiranje u C?
- Razvrstavanje se može izvesti na različite načine na temelju algoritma sortiranja. U programskom jeziku C imamo nekoliko pristupa sortiranju popisa. Pojam sortiranje navodi sređivanje podataka na određeni način, obično uzlaznim redoslijedom. Iako je način sortiranja podataka različit u svim algoritmima sortiranja, ishod svih njih je isti.
- Program obično pretražuje minimalni broj i pomiče ga na početak popisa te ponavlja ista pretraživanja. Kad se ponovno pojavi drugi mali broj, on se pomiče na sljedeći prostor na popisu odmah nakon prvog indeksa i taj se postupak nastavlja ponavljati dok se ne dobije popis sortiranja. Na taj se način sortiranje vrši u programskom jeziku C.
- U svim pristupima sortiranju popisa, niz igra vrlo vitalnu ulogu u programskom jeziku C. Niz se u svakom algoritmu koristi za spremanje popisa elemenata koje je potrebno sortirati. Primjerice, u vrstama mjehurića elementi su pohranjeni u pojedinačnom polju, a vrijednosti u polju su obrađene kako bi ih pretvorili u popis sortiranih podataka.
- U sortiranju odabira, isti se niz tretira kao dva niza u kojima se smatra da je prvi niz prazan da bi mogao reći sortirane vrijednosti, dok drugi niz drži popis neortiziranih. Da bi se iskoristila svrha sortiranja nizova koristi se vrlo često umjesto da vrijednosti drže u pojedinim varijablama. Među svim algoritmima, brzo sortiranje djeluje vrlo brzo i otuda je nazvano brzo razvrstavanje. Potrebno je puno manje vremena u usporedbi s ostalim algoritmima za razvrstavanje.
Vrste sortiranja u C
1. Bubble Sort
- Razvrstavanje mjehurića može se definirati kao algoritam sortiranja koji slijedi pristup zamjene vrijednosti u prvom indeksu najmanjom vrijednošću u nizu i nastavlja ponavljati dok se popis ne razvrsta. To je vrlo jednostavan način sortiranja. Na taj način sortiranje niza, vrijednost se prije početka sortiranja mora dodijeliti nizu.
- Ispod je program za sortiranje nizova pomoću mjehurića gdje su vrijednosti preuzete od korisnika. Nakon što se program sastavi i pokrene, korisnik će tražiti broj elemenata koje želi sortirati. Nakon unosa broja, program će tražiti od korisnika da mu pruži vrijednosti jednake broju koji su dali. Vrijednosti će biti pohranjene u nizu i dalje će se obrađivati koristeći ugniježđenu petlju zajedno s odlukom pomoću "ako" kako bi se sortiralo polje.
- Prva najmanja vrijednost pronađena u nizu premještena je u prvi indeks matrice, a zatim započinje ponovno pronalaženje drugog najmanjeg broja. Kad se pronađe sljedeći najmanji broj, on zamjenjuje vrijednost u drugom indeksu i proces se nastavlja ponavljati dok se niz ne sastoji od poredanog popisa vrijednosti.
Kodirati
#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;
)
Korisnik je predao unos 5 3 60 14 1 2 645. Algoritam je primijenjen na niz koji se sastoji od vrijednosti na način na koji ga korisnik daje, a nakon što je obradio izlaz koji smo dobili je 1 2 3 5 14 60 645,
Izlaz:
2. Izbor sortiranja
- Sorta odabira može se definirati kao drugi algoritam za razvrstavanje popisa u kojem je niz podijeljen u dva niza u kojima bi prvi niz trebao biti prazan, dok se drugi niz sastoji od poništenog popisa vrijednosti. Program traži najmanje vrijednosti u drugom polju i kada se vrijednost nađe, premještena je na početak prvog polja koji je bio prazan. Pristup se iznova ponavlja i sljedeće najmanje vrijednosti bit će prebačene na drugi indeks prvog niza. Postupci će se ponavljati sve dok drugi niz ne postane prazan.
- Program u nastavku je šifriranje implementacije algoritma za odabir odabira. Nakon uspješnog pokretanja programa, korisnik će zatražiti unos broja vrijednosti koje je spreman sortirati. Nakon dobivanja broja, program će tražiti od korisnika da unese vrijednosti za niz koji mora biti sortiran. Vrijednost se zatim obrađuje koristeći ugniježđenu petlju kako bi se sortirali brojevi. Ovdje je uključena i provjera stanja ako je provjerila najmanji broj.
- Postupci će se ponavljati sve dok prvi popis ne bude popunjen popisom. U međuvremenu, programi zadržavaju svoj primarni fokus kako bi provjerili ima li drugi niz vrijednost i ako je pronađena pozitivna, program ponovno pokreće algoritam sortiranja. Iako se popis razvrstava na jednostavan način, može potrajati malo više vremena u odnosu na ostale algoritme. Ali do kraja, rezultat koji će generirati biti će isti kao i ostali algoritmi sortiranja.
Kodirati#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 upit o broju elemenata koje mora biti sortirano, korisnik je u donjem izlazu naveo 6. Kasnije su unesene vrijednosti 25 65 36 86 96 45. Ove vrijednosti su pohranjene u nizu za koji se očekuje da će biti razdvojen u dva niza, gdje će jedan biti prazan za spremanje poredanog popisa, a drugi će imati nesvrstani popis, Nakon obrade unosa, rezultat je bio 25 36 45 65 86 96. Izgubljeni je sortiran odabirom sortiranja. Nakon što su svih šest vrijednosti premještene na prvi niz u razvrstanom obliku, drugi će niz postati prazan i algoritam će se ukinuti.
Izlaz:
3. Brzo sortiranje
- Quicksort se može definirati kao drugi algoritam za razvrstavanje popisa u kojem je pristup da se niz podijeli na vrijednosti veće i manje od vrijednosti do ukupnih vrijednosti ako ih podijelimo u pojedince. U ovom algoritmu, vrijednost posljednjeg indeksa matrice odabrana je kao stožer, a sve vrijednosti manje od stožerne točke pomaknute su u niz koji se očekuje da se pojavi s lijeve strane i elementi koji imaju veću vrijednost nego stožer se pomakne na desni niz. Iz novoformiranog niza koji je imao vrijednosti manje od posljednje vrijednosti okreta, odabran je jedan zaokret. Slično tome, vrijednosti manje od novog stožera bit će pomaknute u polje koji je lijevo, a vrijednosti više od novog stožera pomaknut će se u desnom polju.
- Program u nastavku je quicksort implementacija korištenjem programskog jezika C. Jednom kada se program pokrene, od korisnika će tražiti broj elemenata koje želi sortirati. Na temelju brojanja, petlja for će ponoviti procijenjeno vrijeme kako bi preuzela unos od korisnika. Ulaz će se obraditi pomoću uvjeta if zajedno s petljom for za generiranje sortiranog popisa. Niz će nastaviti s uređivanjem vrijednosti koristeći vrijednost stožera dok sve vrijednosti ne budu provjerene za najmanju vrijednost.
- Razvrstavanje pomoću ovog algoritma previše je brzo u usporedbi s ostalim algoritmima za sortiranje i zato je dobilo naziv brzog sortiranja. Quicksort je jedini algoritam koji vodi u podjelu polja dok se sve vrijednosti ne razdvoje na pojedinačne nizove. Zatim će se dodati ili objediniti u jednom nizu koji se smatra sortiranim popisom.
Kodirati:
#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);
)
)
Na izlazu u nastavku korisnik je potvrdio da će podnijeti 6 vrijednosti i da će formirati popis razvrstanih podataka. Nakon davanja broja, vrijednosti koje pruža korisnik su 56, 35, 24, 86, 98, 2. Na ove vrijednosti primijenjen je brzi skup i generiran je popis sortiranja koji ima vrijednost 2, 24, 35, 56, 86, 98.
Izlaz:
4. Spajanje sortiranja
- Spajanje sortiranja može se definirati kao drugi algoritam sortiranja koji vrši sortiranje razdvajanjem polja do posljednjeg kada se pretvara u pojedinačnu vrijednost i zatim ih združivanjem na način da se može pretvoriti u sortirani niz.
- Proces oduzima malo puno vremena u usporedbi s ostalim rivalskim algoritmima, ali se smatra prilično učinkovitim u usporedbi s ostalim. Kad je u pitanju razvrstavanje velikog popisa, ovaj algoritam djeluje vrlo u redu i zato je preferiran u razvoju aplikacije koja mora obraditi veliki popis.
Kodirati:
#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);
)
Kad se gornji kôd pokrene, prvo traži od korisnika da navede broj elemenata koje želi sortirati. Nakon podnošenja broja morat će se unijeti jednake vrijednosti koje su prvotno naveli. Nakon što su poslane vrijednosti, algoritam će te vrijednosti držati u matrici i obraditi ih da transformira matricu u sortirani niz. Nakon što se niz razvrsta uzlaznim redoslijedom, korisnik će prikazati izlaz.
Izlaz:
5. Zloduh
- Poredak hrpe može se definirati kao algoritam sortiranja koji radi pretraživanjem maksimalnog elementa na popisu i stavljanjem na posljednji. Algoritam izvršava radnju rekurzivno dok se niz ne razvrsta na uzlazni način.
- Proces je da se odabere maksimalna vrijednost i da se premjesti na zadnju, a smatra se i manje učinkovitim pristupom razvrstavanju kada je riječ o razvrstavanju velikog popisa. Međutim, on dobro uspijeva s popisom koji ima ograničen broj vrijednosti. Ispod je implementacija ovog algoritma u programskom jeziku C zajedno s izlazom.
Kodirati:
#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;
)
)
)
Rad ovog algoritma isti je kao i kod ostalih algoritama za razvrstavanje, jer on također sortira popis uzlaznim redoslijedom. Kad se gore napisani kod pokrene, korisnik mora poslati broj vrijednosti koje će sortirati. Nakon što se vrijednosti predaju, kod će ih obraditi kako bi se niz pretvorio u razvrstani. Izlaz će se prikazati na kraju i može se primijetiti da su vrijednosti koje je korisnik predao razvrstavali uzlaznim redoslijedom.
Izlaz:
6. Umetanje vrsta
- Umetanje vrsta može se definirati kao algoritam sortiranja koji djeluje pomicanjem minimalne vrijednosti na početku popisa jedan po jedan. Ovo je vrlo manje učinkovit algoritam sortiranja i nije pogodno za obradu s velikim popisom.
- Ovaj pristup sortiranja algoritma djeluje vrlo sporo i obično se ne preferira u nijednoj aplikaciji. To može biti dobro s popisom koji sadrži prilično mali broj elemenata. Za aplikacije koje imaju zahtjev za obradu nekoliko brojeva vrijednosti mogu se koristiti ovaj algoritam.
Kodirati:
#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;
)
Kada se program pokrene, korisnik će morati unijeti broj vrijednosti koje mora sortirati. Nakon toga, vrijednosti koje je unijeo korisnik bit će spremljene u niz. Zatim će se preraditi i upotrebom for za provjeru petlje i uvjeta minimalna vrijednost pomaknut će se na početak u svakoj rekurziji i završiti generiranjem sortirane matrice. Vrijednosti će biti prikazane korisniku na kraju programa.
Izlaz:
Zaključak
Algoritam sortiranja koristi se za generiranje poredanog popisa koji je normalan popis na kojem su sve vrijednosti sortirane na određeni način. Popis se vrlo često koristio u stvarnoj primjeni da bi se donijele neke funkcionalnosti. U ovom smo članku pokrenuli sortiranje mjehurića, sortiranje odabira i brzi odabir, dok postoji i nekoliko drugih algoritama poput spajanja sorti koje se mogu koristiti za stvaranje popisa. Među svim algoritmima za razvrstavanje, quicksort djeluje vrlo brzo i pomaže u sortiranju popisa vrlo brzo. Ovdje napisani programi u osnovi su za implementaciju ovih algoritama sortiranja pomoću programskog jezika C. Ako ste voljni primijeniti isto u drugim programskim jezicima, možete se služiti istom logikom i jedino što može varirati mogu biti sintaksa i ključne riječi.
Preporučeni članak
Ovo je vodič za sortiranje u C. Ovdje smo raspravljali o uvodu u Sortiranje u C i različitim vrstama sortiranja, zajedno s kodom uzorka. Možete i proći naše druge predložene članke da biste saznali više -
- Obrasci u C programiranju
- Palindrome u C programu
- Spajanje sortiranja u Javi
- Uvod u razvrstavanje u R
- Uvod u razvrstavanje u C ++
- Pregled sortiranja u PHP-u
- Poredajte u Python
- Funkcija sortiranja u Python-u s primjerima
