Introduktion till sortering i C
I applikationen känner utvecklarna lusten att sortera data för att låta få speciell funktionalitet. Det finns flera metoder för att sortera data och de räknas under sortering enligt nomenklaturen. Sortering kan definieras som metoden för att ordna data på ett visst sätt som följer någon ordning. Här i det här avsnittet ska vi lära oss om sortering med C-programmeringsspråket. Det finns flera typer av sortering som bubbelsortering, sammanslagningssortering, markeringssortering, insättningssortering och så vidare. Vi kommer att göra verklig kodning för de sorteringsmetoder som används ofta i applikationen. Koderna kommer att vara tillgängliga för dig i ett textformat så att du kan hitta det enkelt att använda den koden medan utgången kommer att visas i skärmdumpen för att ge dig inblick i den faktiska utdata som kommer efter att ha kört programmet.
Hur sortering utförs i C?
- Sortering kan utföras på olika sätt baserat på sorteringsalgoritmen. På programmeringsspråk C har vi flera sätt att sortera listan. Termen sortering anger arrangering av data på ett visst sätt vanligtvis i stigande ordning. Även om sättet att sortera data är annorlunda i alla sorteringsalgoritmer, är resultatet av dem alla samma.
- I sortering söker programmet oftast efter minsta antal och flyttade det numret till början av listan och upprepar samma sökningar. När det andra lilla antalet återigen möts flyttas det till nästa utrymme i listan direkt efter det första indexet och denna process fortsätter att upprepa tills sorteringslistan erhålls. Så här görs sortering på C-programmeringsspråket.
- I alla metoder för att sortera listan spelar matrisen en mycket viktig roll i programmeringsspråket C. I varje algoritm har matrisen använts för att lagra listan över de element som måste sorteras. Till exempel, i bubblasortering, lagras elementen i en enda matris och värdena i arrayen har bearbetats för att konvertera dem till en lista med sorterade data.
- I urvalsorten har samma matris behandlats som två matriser där den första matrisen anses vara ledig för att berätta de sorterade värdena medan den andra matrisen har den osorterade listan. För att tjäna syftet med att sortera matrisen används mycket ofta istället för att hålla värdena i enskilda variabler. Bland alla algoritmerna fungerar snabbsortering mycket snabbt och därmed benämns snabbsortering. Det tar mycket mindre tid jämfört med de andra sorteringsalgoritmerna.
Typer av sortering i C
1. Bubble Sort
- Bubbelsortering kan definieras som sorteringsalgoritmen som följer tillvägagångssättet att ersätta värdet i det första indexet med det minsta värdet i matrisen och hålla den upprepad tills listan är sorterad. Det är ett mycket enkelt sätt att utföra sortering. På detta sätt för att sortera matrisen måste värdet tilldelas arrayen i början innan sorteringen startas.
- Nedan är programmet för att sortera matrisen med bubbelsorter där värdena har tagits från användaren. När programmet har sammanställts och körts kommer det att be användaren om antalet element som de vill sortera. När numret har angetts kommer programmet att be användaren att tillhandahålla värden som motsvarar det antal som de har angett. Värdena kommer att lagras i arrayen och behandlas vidare med kapslad för loop tillsammans med beslutsfattande med ”if” för att sortera arrayen.
- Det första minsta värdet som hittades i arrayen har flyttats till det första indexet i arrayen och sedan börjar sökningen igen för att hitta det andra minsta antalet. När nästa minsta nummer hittas ersätter det värdet i det andra indexet och processen fortsätter att upprepa tills matrisen består av en sorterad lista med värden.
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;
)
Användaren har skickat in ingången 5 3 60 14 1 2 645. Algoritmen har applicerats på matrisen bestående av värden på det sätt som den tillhandahålls av användaren och efter bearbetning av den är den utgång vi fick 1 2 3 5 14 60 645 .
Produktion:
2. Urvalssortering
- Urvalssorteringen kan definieras som en annan algoritm för att sortera listan där arrayen är uppdelad i två matriser där den första matrisen är tänkt att vara tom medan den andra arrayen består av den osorterade värdelistan. Programmet söker efter de minsta värdena i den andra arrayen och när värdet hittas har det flyttats till början av den första arrayen som var tom. Tillvägagångssättet upprepas igen och de nästa minsta värdena flyttas till det andra indexet i den första matrisen. Processerna kommer att fortsätta att upprepa tills den andra arrayen blev tom.
- Nedanstående program är kodningsimplementeringen av urvalsorteringsalgoritmen. När programmet har körts framgångsrikt kommer det att begära användaren att mata in antalet värden som de är villiga att sortera. När räkningen har uppnåtts kommer programmet att be användaren att mata in värdena för den matris som måste sorteras. Värdet bearbetas sedan med kapslad för slinga för att sortera siffrorna. Om tillståndskontrollen har också varit inblandad här för att kontrollera det minsta antalet.
- Processerna upprepas tills den första listan är full av den sorterade listan. Samtidigt behåller programmen sitt primära fokus för att kontrollera om den andra matrisen har värde och om den befinner sig positiv kör programmet sorteringsalgoritmen igen. Även om den sorterar listan på enkelt sätt kan det ta lite mer tid jämfört med de andra algoritmerna. Men i slutet kommer resultatet att genereras vara detsamma som de andra sorteringsalgoritmerna.
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();
)
När användaren har frågat om antalet element som måste sorteras har användaren tillhandahållit 6 i utgången nedan. Senare är värdena som har matats in 25 65 36 86 96 45. Dessa värden lagras i matrisen som förväntas delas upp i två matriser där en kommer att vara tom för att lagra den sorterade listan och den andra kommer att ha den osorterade listan . Efter bearbetning av ingången var resultatet 25 36 45 65 86 96. Detta förlorade har sorterats med markeringen. När alla de sex värdena har flyttats till den första matrisen i den sorterade formen, kommer den andra arrayen att bli tom och algoritmen avslutas.
Produktion:
3. Snabbsortering
- Quicksort kan definieras som den andra algoritmen för att sortera listan där tillvägagångssättet är att dela upp arket i termer av större än och mindre än värden tills hela värdena om de delas upp i individer formar. I denna algoritm har värdet på det sista indexet i matrisen valts som en pivot och alla värden mindre än pivot har flyttats till den matris som förväntas inträffa till vänster om värdet och elementen med ett högre värde än pivot flyttas till höger matris. Återigen väljs en pivot från den nybildade matrisen som hade värdena mindre än det sista pivotvärdet. På samma sätt kommer värdena som är mindre än den nya pivoten att flyttas till den matris som kommer att lämnas och värdena mer än den nya pivoten kommer att flyttas i den högra matrisen.
- Nedanstående program är implementeringen av quicksort med programmeringsspråket C. När programmet körs kommer det att be användaren om antalet element som de vill sortera. Baserat på räkningen kommer for-loopen att upprepa uppskattade tider för att ta input från användaren. Ingången behandlas med if-villkoren tillsammans med for-loopen för att generera en sorterad lista. Arrayen fortsätter att ordna värdena med hjälp av pivotvärdet tills alla värden har kontrollerats för det minsta värdet.
- Sorteringen som görs med denna algoritm är alldeles för snabbare jämfört med de andra sorteringsalgoritmerna och det är därför den har fått namnet snabbsortering. Quicksort är den enda algoritmen som leder till att uppdelningen delas tills alla värden separeras i de enskilda matriserna. De kommer sedan att läggas till eller aggregeras i en enda grupp som betraktas som den sorterade listan.
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);
)
)
I nedanstående utgång bekräftade användaren att de kommer att skicka 6 värden och att bilda en lista med sorterade data. Efter uppräkningen är värdena som tillhandahålls av användaren 56, 35, 24, 86, 98, 2. Quicksort har tillämpats på dessa värden och den sorterade listan har genererats som har värdet 2, 24, 35, 56, 86, 98.
Produktion:
4. Slå samman
- Sorteringssortering kan definieras som en annan sorteringsalgoritm som utför sorteringen genom att segregera matrisen till sist när den förvandlas till ett individuellt värde och sedan aggregera dem på ett sätt så att det kan förvandlas till en sorterad matris.
- Processen tar lite tid jämfört med de andra konkurrerande algoritmerna, men det anses vara ganska effektivt jämfört med andra. När det gäller att sortera en stor lista fungerar denna algoritm mycket bra och föredras därför för att utveckla applikationen som måste behandla den stora listan.
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);
)
När koden ovan körs ber den först användaren att ange antalet element som de vill sortera. När numret har skickats in kommer de att behöva ange värden för lika antal som de tillhandahöll inledningsvis. När värdena har skickats kommer algoritmen att innehålla dessa värden i arrayen och kommer att bearbeta den för att omvandla arrayen till den sorterade arrayen. Efter att matrisen har sorterats i stigande ordning, kommer utdata att visas för användaren.
Produktion:
5. Heapsort
- Heapsorteringen kan definieras som sorteringsalgoritmen som fungerar genom att söka i det maximala elementet i listan och placera det till det sista. Algoritmen utför åtgärden rekursivt tills matrisen sorteras på stigande sätt.
- Det är mycket tid att ta processen att välja det högsta värdet och flytta det till det sista och därför betraktas det som en mindre effektiv sorteringsmetod när det gäller att sortera den stora listan. Men det fungerar bra med listan som har ett begränsat antal värden. Nedan visas implementeringen av denna algoritm på programmeringsspråket C tillsammans med utgången.
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;
)
)
)
Arbetet med den här algoritmen är densamma som för andra sorteringsalgoritmer eftersom den också sorterar listan i stigande ordning. När den ovan skrivna koden körs måste användaren lämna in antalet värden som de kommer att sortera. När värdena har skickats, kommer koden att bearbeta dem för att förvandla matrisen till den sorterade. Utgången visas så småningom och det kan observeras att värdena som har skickats in av användaren har sorterats i stigande ordning.
Produktion:
6. Insertion Sort
- Insättningssortering kan definieras som sorteringsalgoritmen som fungerar genom att flytta minimivärdet i början av listan en åt gången. Detta är en mycket mindre effektiv sorteringsalgoritm och inte hittad lämplig att hantera den stora listan.
- Denna metod för att sortera algoritmen fungerar mycket långsamt och vanligtvis föredras inte i någon av applikationerna. Det kan fungera bra med listan som har ganska få antal element. För applikationer som har krav på att behandla några få värden kan utnyttja denna algoritm.
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;
)
När programmet körs måste användaren ange antalet värden som de behöver sortera. Efteråt kommer värdena som anges av användaren lagras i matrisen. De kommer sedan att bearbetas och genom användning av för loop- och tillståndskontroll flyttas minimivärdet till början i varje rekursion och slutar genom att generera en sorterad matris. Värdena visas för användaren i slutet av programmet.
Utgång:
Slutsats
Sorteringsalgoritmen används för att generera en sorterad lista som är en normal lista där alla värden sorteras på ett visst sätt. Listan har använts mycket ofta i den faktiska applikationen för att få vissa funktioner. I den här artikeln har vi täckt bubbelsortering, urvalssortering och kvicksort medan det finns flera andra algoritmer som blandningssortering också finns där som kan utnyttjas för att generera en sorterad lista. Bland alla sorteringsalgoritmer fungerar quicksort mycket snabbt och hjälper till att sortera listan mycket snabbt. Programmen som skrivs här är i grund och botten för att implementera dessa sorteringsalgoritmer med C-programmeringsspråket. Om du är villig att implementera samma på andra programmeringsspråk kan du använda samma logik och det enda som kan variera kan vara syntax och nyckelord.
Rekommenderad artikel
Detta har varit en guide till sortering i C. Här diskuterar vi en introduktion i sortering i C och olika typer av sortering tillsammans med provkod. Du kan också gå igenom våra andra föreslagna artiklar för att lära dig mer -
- Mönster i C-programmering
- Palindrome in C-programmet
- Slå samman sortering i Java
- Introduktion till sortering i R
- Introduktion till sortering i C ++
- Översikt över sortering i PHP
- Heap Sort i Python
- Sorteringsfunktion i Python med exempel