Introducere în Sortare în C
În aplicație, dezvoltatorii simt nevoia de a sorta datele pentru a lăsa să aducă o funcționalitate specială. Există mai multe abordări pentru a sorta datele și acestea sunt contorizate în funcție de sortare conform nomenclaturii. Sortarea poate fi definită ca metoda de aranjare a datelor într-o anumită manieră care urmează o anumită ordine. Aici, în această secțiune, vom învăța despre sortare folosind limbajul de programare C. Există mai multe tipuri de sortare cum ar fi sortarea cu bule, sortare de îmbinare, sortare de selecție, sortare de inserție etc. Vom face codări efective pentru metodele de sortare care sunt utilizate foarte des în aplicație. Codurile vă vor fi disponibile într-un format textual, astfel încât să puteți găsi ușor de utilizat codul respectiv, în timp ce ieșirea va fi afișată în captură de ecran pentru a vă oferi informații despre ieșirea reală care vine după rularea programului.
Cum se realizează sortarea în C?
- Sortarea poate fi efectuată în diferite moduri pe baza algoritmului de sortare. În limbajul de programare C avem mai multe abordări pentru a sorta lista. Termenul de sortare prevede aranjarea datelor într-o manieră particulară, de obicei în ordine crescătoare. Deși modul de sortare a datelor este diferit în toți algoritmii de sortare, rezultatul tuturor acestora este același.
- De obicei, la sortare, programul caută numărul minim și trece acest număr la începutul listei și repetă aceleași căutări. Din nou, odată întâlnit celălalt număr mic, acesta este mutat la următorul spațiu din listă imediat după primul index și acest proces continuă să se repete până la obținerea listei de sortare. Acesta este modul în care se face sortarea în limbajul de programare C.
- În toate abordările de sortare a listei, tabloul joacă un rol foarte important în limbajul de programare C. În fiecare algoritm, matricea a fost utilizată pentru a stoca lista elementelor care trebuie sortate. De exemplu, în sortarea cu bule, elementele sunt stocate într-un singur tablou și valorile din tablă au fost procesate pentru a le converti într-o listă de date sortate.
- În sortarea de selecție, același tablou a fost tratat ca două tablouri în care primul tablou este considerat a fi vacant pentru a spune valorile sortate în timp ce al doilea tablou deține lista nesortată. Pentru a servi scopul sortării tabloului se folosește foarte des în loc să păstreze valorile în variabile individuale. Printre toți algoritmii, sortarea rapidă funcționează foarte repede și, prin urmare, este numită sortare rapidă. Durează mult mai puțin timp în comparație cu ceilalți algoritmi de sortare.
Tipuri de sortare în C
1. Sortare cu bule
- Sortarea cu bule poate fi definită ca algoritmul de sortare care urmează abordarea înlocuirii valorii din primul index cu cea mai mică valoare din tablă și să o mențină repetând până la sortarea listei. Este un mod foarte simplu de a efectua sortarea. În acest fel, pentru a sorta matricea, valoarea trebuie să fie atribuită la început, înainte de a începe sortarea.
- Mai jos este programul de sortare a tabloului folosind sortarea cu bule unde valorile au fost preluate de la utilizator. Odată ce programul este compilat și rulat, acesta va solicita utilizatorului numărul de elemente pe care dorește să le sorteze. Odată furnizat numărul, programul va solicita utilizatorului să furnizeze valori echivalente cu numărul pe care l-au furnizat. Valorile vor fi stocate în tablă și vor fi procesate în continuare folosind cuiburi pentru buclă, împreună cu luarea deciziilor folosind „dacă” pentru a sorta matricea.
- Prima cea mai mică valoare găsită în tablou a fost mutată la primul index al tabloului și apoi căutarea începe din nou pentru a găsi celălalt număr cel mai mic. Odată găsit următorul număr cel mai mic, acesta înlocuiește valoarea din al doilea index și procesul continuă să se repete până când tabloul constă într-o listă sortată de valori.
Cod
#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;
)
Utilizatorul a trimis intrarea 5 3 60 14 1 2 645. Algoritmul a fost aplicat pe tabloul format din valori în modul în care este furnizat de utilizator, iar după procesarea acesteia, ieșirea pe care am primit-o este 1 2 3 5 14 60 645 .
ieşire:
2. Sortare selecție
- Sortarea de selecție poate fi definită ca un alt algoritm pentru sortarea listei în care matricea este bifurcată în două tablouri unde se presupune că primul tablou este gol, în timp ce al doilea tablou constă din lista nesortată de valori. Programul caută cele mai mici valori din cel de-al doilea tablou și atunci când valoarea este găsită, a fost mutată la începutul primului tablou care era gol. Abordarea se repetă din nou și valorile următoare cele mai mici vor fi trecute la al doilea index al primului tablou. Procesele se vor repeta până când al doilea tablou a devenit gol.
- Programul de mai jos este implementarea de codare a algoritmului de sortare a selecției. Odată ce programul rulează cu succes, acesta va solicita utilizatorului să introducă numărul de valori pe care este dispus să le sorteze. După obținerea numărului, programul va solicita utilizatorului să introducă valorile pentru tabloul care trebuie sortat. Valoarea este apoi procesată folosind cuib pentru buclă pentru a sorta numerele. Verificarea condițiilor dacă a fost implicată și aici pentru a verifica cel mai mic număr.
- Procesele vor fi repetate până când prima listă va fi completă cu lista ordonată. Între timp, programele își păstrează accentul principal pentru a verifica dacă al doilea tablou are valoare și dacă este găsit pozitiv, programul rulează din nou algoritmul de sortare. Deși ordonează lista într-o manieră ușoară, poate dura ceva mai mult în comparație cu ceilalți algoritmi. Dar până la sfârșit, rezultatul pe care îl va genera va fi același cu alți algoritmi de sortare.
Cod#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();
)
La solicitarea numărului de elemente care trebuie sortate, utilizatorul a furnizat 6 în ieșirea de mai jos. Ulterior, valorile introduse sunt 25 65 36 86 96 45. Aceste valori sunt stocate în tablou, care este de așteptat să fie bifurcate în două tablouri unde unul va fi gol pentru a stoca lista sortată, iar celălalt va avea lista nesortată. . După procesarea intrării, rezultatul a fost de 25 36 45 65 86 96. Această pierdere a fost sortată folosind sortarea de selecție. Odată ce toate cele șase valori au fost mutate în primul tablou în forma sortată, al doilea tablou va deveni gol și algoritmul va fi încheiat.
ieşire:
3. Sortare rapidă
- Quicksort poate fi definit ca celălalt algoritm pentru sortarea listei în care abordarea este de a împărți matricea în termeni mai mari și mai mici decât valorile, până la formele întregi, dacă se împarte în indivizi. În acest algoritm, valoarea ultimului indice al tabloului a fost selectată ca pivot și toate valorile mai mici decât pivot au fost mutate în tabloul care este de așteptat să apară în stânga valorii și elementele care au o valoare mai mare decât pivotul sunt mutați la tabloul potrivit. Din nou este selectat un pivot din tabloul nou format care a avut valorile mai mici decât ultima valoare a pivotului. În mod similar, valorile mai mici decât noul pivot vor fi mutate în tabloul care va fi lăsat și valorile mai mult decât noul pivot vor fi mutate în tabloul din dreapta.
- Programul de mai jos este implementarea quicksort folosind limbajul de programare C. Odată ce programul este executat, acesta va solicita utilizatorului numărul de elemente pe care dorește să le sorteze. Pe baza numărului, bucla for va itera timpii estimate pentru a lua intrarea de la utilizator. Intrarea va fi procesată folosind condițiile if împreună cu bucla for pentru a genera o listă sortată. Matricea va continua să aranjeze valorile folosind valoarea pivot până când toate valorile vor fi verificate pentru cea mai mică valoare.
- Sortarea efectuată cu acest algoritm este mult mai rapidă în comparație cu ceilalți algoritmi de sortare și de aceea a fost numită sortare rapidă. Quicksort este singurul algoritm care duce la împărțirea tabloului până când toate valorile sunt separate în matricile individuale. Acestea vor fi apoi adăugate sau agregate într-un singur tablou care este considerat lista sortată.
Cod:
#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);
)
)
În ieșirea de mai jos, utilizatorul a confirmat că va trimite 6 valori și va forma o listă de date sortate. După furnizarea numărării, valorile furnizate de utilizator sunt 56, 35, 24, 86, 98, 2. Quicksort-ul a fost aplicat la aceste valori și s-a generat lista sortată care are valoarea 2, 24, 35, 56, 86, 98.
ieşire:
4. Sortare Merge
- Sortarea Merge poate fi definită ca un alt algoritm de sortare care realizează sortarea prin segregarea tabloului până la ultima dată când se transformă într-o valoare individuală și apoi le agregă într-o manieră, astfel încât să se poată transforma într-un tablou sortat.
- Procesul consumă puțin timp în comparație cu ceilalți algoritmi rivali, dar este considerat destul de eficient în comparație cu alții. Când vine vorba de sortarea unei liste mari, acest algoritm funcționează foarte bine și, prin urmare, este preferat în dezvoltarea aplicației care trebuie să proceseze lista mare.
Cod:
#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);
)
Când rulează codul de mai sus, acesta solicită mai întâi utilizatorului să furnizeze numărul de elemente pe care dorește să le sorteze. Odată ce numărul a fost transmis, va trebui să furnizeze valorile numărului egal pe care le-au furnizat inițial. Odată ce valorile au fost transmise, algoritmul va reține acele valori în tablou și îl va procesa pentru a transforma tabloul în tablă sortată. După ce tabloul este sortat în ordine crescătoare, ieșirea va fi afișată utilizatorului.
ieşire:
5. Heapsort
- Sortarea heap poate fi definită ca algoritmul de sortare care funcționează căutând elementul maxim din listă și plasându-l la ultimul. Algoritmul execută acțiunea în mod recursiv până când tabloul este sortat în modul ascendent.
- Este foarte necesar ca procesul să alegeți valoarea maximă și să o mutați la ultima și, prin urmare, este considerată o abordare de sortare mai puțin eficientă când vine vorba de sortarea listei mari. Cu toate acestea, funcționează bine cu lista care are un număr limitat de valori. Mai jos este implementarea acestui algoritm în limbajul de programare C împreună cu rezultatul.
Cod:
#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;
)
)
)
Funcționarea acestui algoritm este aceeași cu cea a altor algoritmi de sortare, deoarece ordonează și lista în ordine crescătoare. Când se rulează codul scris mai sus, utilizatorul trebuie să trimită numărul de valori pe care le va sorta. Odată ce valorile sunt transmise, codul le va prelucra pentru a transforma tabloul în cea sortată. Ieșirea va fi afișată în cele din urmă și se poate observa că valorile transmise de utilizator au sortat în ordine crescătoare.
ieşire:
6. Sortare inserție
- Sortarea de inserție poate fi definită ca algoritmul de sortare care funcționează prin mutarea valorii minime la începutul listei, la rând. Acesta este un algoritm de sortare foarte puțin eficient și nu este găsit potrivit pentru a face față listei mari.
- Această abordare a sortării algoritmului funcționează foarte lent și de obicei nu este preferată în niciuna dintre aplicații. Poate funcționa bine cu lista care are destul de puține numere de elemente. Pentru aplicații, care au cerința de a procesa câteva numere de valori, pot folosi acest algoritm.
Cod:
#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;
)
Când programul rulează, utilizatorul va trebui să introducă numărul de valori pe care trebuie să le sorteze. Ulterior, valorile introduse de utilizator vor fi stocate în tablou. Vor trece apoi în procesare și prin verificarea buclelor și a condițiilor, valoarea minimă va fi mutată la început în fiecare recurs și va ajunge la generarea unui tablou sortat. Valorile vor fi afișate utilizatorului la sfârșitul programului.
Rezultat:
Concluzie
Algoritmul de sortare este utilizat pentru a genera o listă sortată care este o listă normală în care toate valorile sunt sortate într-o manieră particulară. Lista a fost folosită foarte des în aplicația reală pentru a aduce unele funcționalități. În acest articol am acoperit sortarea de bule, sortarea selecției și interogarea în timp ce există mai mulți alți algoritmi, cum ar fi sortarea de îmbinare, există, de asemenea, care pot fi utilizate pentru a genera o listă sortată. Printre toți algoritmii de sortare, quicksort funcționează foarte repede și ajută la sortarea listei foarte repede. Programele scrise aici sunt practic pentru a implementa acești algoritmi de sortare folosind limbajul de programare C. Dacă sunteți dispus să implementați același lucru în alte limbaje de programare, puteți utiliza aceeași logică și singurul lucru care poate varia poate fi sintaxa și cuvintele cheie.
Articol recomandat
Acesta a fost un ghid pentru Sortarea în C. Aici vom discuta o introducere în Sortare în C și diferite tipuri de sortare împreună cu codul de probă. Puteți parcurge și alte articole sugerate pentru a afla mai multe -
- Modele în programarea C
- Palindrom în programul C
- Sortare sortare în Java
- Introducere în Sortarea în R
- Introducere în Sortare în C ++
- Prezentare generală a sortării în PHP
- Sort de grămadă în Python
- Funcția de sortare în Python cu exemple