Inleiding tot sorteren in C
In de applicatie hebben de ontwikkelaars de behoefte om de gegevens te sorteren om bepaalde functionaliteit te kunnen bieden. Er zijn verschillende benaderingen om de gegevens te sorteren en ze worden geteld volgens de classificatie volgens de nomenclatuur. Sorteren kan worden gedefinieerd als de methode voor het ordenen van de gegevens op een bepaalde manier die een bepaalde volgorde volgt. Hier in dit gedeelte gaan we leren sorteren met de programmeertaal C. Er zijn verschillende soorten sortering, zoals de bubbelsortering, samenvoegsortering, selectiesortering, invoegsortering enzovoort. We zullen daadwerkelijke codering uitvoeren voor de sorteermethoden die heel vaak in de toepassing worden gebruikt. De codes zijn voor u beschikbaar in een tekstuele indeling, zodat u het gemakkelijk kunt vinden om die code te gebruiken, terwijl de uitvoer wordt weergegeven in de screenshot om u inzicht te geven in de werkelijke uitvoer die wordt uitgevoerd na het uitvoeren van het programma.
Hoe sorteren wordt uitgevoerd in C?
- Sorteren kan op verschillende manieren worden uitgevoerd op basis van het sorteeralgoritme. In de programmeertaal C hebben we verschillende benaderingen om de lijst te sorteren. Met de term sorteren wordt gegevens op een bepaalde manier gerangschikt, meestal in oplopende volgorde. Hoewel de manier om de gegevens te sorteren in alle sorteeralgoritmen anders is, is het resultaat van allemaal hetzelfde.
- Gewoonlijk zoekt het programma bij het sorteren naar het minimumaantal en verschoof dat nummer naar het begin van de lijst en herhaalt het dezelfde zoekopdrachten. Nogmaals, zodra het andere kleine aantal wordt aangetroffen, wordt het naar de volgende spatie in de lijst verplaatst direct na de eerste index en dit proces blijft zich herhalen totdat de sorteerlijst is verkregen. Dit gebeurt op de manier van sorteren in de C-programmeertaal.
- Bij alle benaderingen om de lijst te sorteren, speelt de array een zeer vitale rol in de C-programmeertaal. In elk algoritme is de array gebruikt om de lijst op te slaan van de elementen die moeten worden gesorteerd. In bubbelsortering worden de elementen bijvoorbeeld opgeslagen in de enkele array en worden de waarden in de array verwerkt om ze om te zetten in een lijst met gesorteerde gegevens.
- In de selectiesortering is dezelfde array behandeld als twee arrays waarbij de eerste array als leeg wordt beschouwd om de gesorteerde waarden te vertellen, terwijl de tweede array de ongesorteerde lijst bevat. Om het doel van het sorteren te dienen, wordt de array heel vaak gebruikt in plaats van de waarden in afzonderlijke variabelen vast te houden. Van alle algoritmen werkt snel sorteren erg snel en wordt daarom snel sorteren genoemd. Het kost veel minder tijd in vergelijking met de andere sorteeralgoritmen.
Soorten sortering in C
1. Bellen sorteren
- Bubbelsortering kan worden gedefinieerd als het sorteeralgoritme dat de benadering volgt van het vervangen van de waarde in de eerste index door de kleinste waarde in de array en deze blijven herhalen totdat de lijst is gesorteerd. Het is een zeer eenvoudige manier om te sorteren. Op deze manier om de array te sorteren, moet de waarde in het begin aan de array worden toegewezen voordat het sorteren begint.
- Hieronder staat het programma om de array te sorteren met behulp van bubbelsortering waarbij de waarden van de gebruiker zijn overgenomen. Nadat het programma is gecompileerd en uitgevoerd, wordt de gebruiker gevraagd om het aantal elementen dat hij wil sorteren. Zodra het nummer is opgegeven, zal het programma de gebruiker vragen waarden op te geven die gelijk zijn aan het aantal dat ze hebben opgegeven. De waarden worden opgeslagen in de array en worden verder verwerkt met behulp van geneste for-lus samen met besluitvorming met "if" om de array te sorteren.
- De eerste kleinste waarde die in de array is gevonden, is verplaatst naar de eerste index van de array en vervolgens begint het zoeken opnieuw om het andere kleinste getal te vinden. Zodra het volgende kleinste getal is gevonden, vervangt het de waarde in de tweede index en blijft het proces herhalen totdat de array uit een gesorteerde lijst met waarden bestaat.
Code
#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;
)
De gebruiker heeft de invoer 5 3 60 14 1 2 645 ingediend. Het algoritme is toegepast op de array bestaande uit waarden op de manier die door de gebruiker wordt verstrekt en na verwerking is de uitvoer die we hebben ontvangen 1 2 3 5 14 60 645 .
Output:
2. Selectie sorteren
- De selectiesortering kan worden gedefinieerd als een ander algoritme voor het sorteren van de lijst waarin de array is gesplitst in twee arrays waarbij de eerste array verondersteld wordt leeg te zijn terwijl de tweede array bestaat uit de ongesorteerde zoeklijst. Het programma zoekt naar de kleinste waarden in de tweede array en wanneer de waarde is gevonden, is deze verplaatst naar het begin van de eerste array die leeg was. De benadering wordt opnieuw herhaald en de volgende kleinste waarden worden verschoven naar de tweede index van de eerste reeks. De processen blijven zich herhalen totdat de tweede array leeg is.
- Het onderstaande programma is de coderingsimplementatie van het selectie-sorteeralgoritme. Als het programma eenmaal is uitgevoerd, wordt de gebruiker gevraagd het aantal waarden in te voeren dat hij wil sorteren. Zodra de telling is verkregen, zal het programma de gebruiker vragen om de waarden in te voeren voor de array die moet worden gesorteerd. De waarde wordt vervolgens verwerkt met behulp van genest voor lus om de getallen te sorteren. De if conditie controle is hier ook betrokken geweest om het kleinste aantal te controleren.
- De processen worden herhaald totdat de eerste lijst vol is met de gesorteerde lijst. Ondertussen houden de programma's hun primaire focus om te controleren of de tweede array waarde heeft en als het positief wordt bevonden, voert het programma het sorteeralgoritme opnieuw uit. Hoewel het de lijst op eenvoudige manier sorteert, kan het iets meer tijd kosten in vergelijking met de andere algoritmen. Maar uiteindelijk zal het resultaat dat het genereert hetzelfde zijn als de andere sorteeralgoritmen.
Code#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();
)
Bij het vragen om het aantal elementen dat moet worden gesorteerd, heeft de gebruiker 6 opgegeven in de onderstaande uitvoer. Later zijn de ingevoerde waarden 25 65 36 86 96 45. Deze waarden worden opgeslagen in de array waarvan wordt verwacht dat deze wordt gesplitst in twee arrays waar de ene leeg is om de gesorteerde lijst op te slaan en de andere de ongesorteerde lijst heeft . Na verwerking van de invoer was de uitkomst 25 36 45 65 86 96. Dit verlies is gesorteerd met behulp van de selectiesoort. Nadat alle zes waarden in de gesorteerde vorm naar de eerste array zijn verplaatst, wordt de tweede array leeg en wordt het algoritme beëindigd.
Output:
3. Snel sorteren
- Quicksort kan worden gedefinieerd als het andere algoritme voor het sorteren van de lijst waarin de benadering bestaat uit het verdelen van de array in termen van groter dan en kleiner dan waarden tot de gehele waarden indien verdeeld in individuele vormen. In dit algoritme is de waarde van de laatste index van de array geselecteerd als een pivot en zijn alle waarden kleiner dan pivot verschoven naar de array die naar verwachting links van de waarde zal voorkomen en de elementen met een hogere waarde dan worden de pivot naar de juiste array verplaatst. Wederom wordt een pivot gekozen uit de nieuw gevormde array met de waarden kleiner dan de laatste pivotwaarde. Op dezelfde manier worden de waarden die kleiner zijn dan de nieuwe pivot verschoven naar de array die overblijft en worden de waarden meer dan de nieuwe pivot verschoven in de rechter array.
- Het onderstaande programma is de quicksort-implementatie met behulp van de C-programmeertaal. Zodra het programma wordt uitgevoerd, wordt de gebruiker gevraagd om het aantal elementen dat hij wil sorteren. Op basis van de telling zal de for-lus geschatte tijden herhalen om de invoer van de gebruiker te ontvangen. De invoer wordt verwerkt met behulp van de if-voorwaarden samen met de for-lus om een gesorteerde lijst te genereren. De array blijft de waarden rangschikken met behulp van de spilwaarde totdat alle waarden zijn gecontroleerd op de kleinste waarde.
- Het sorteren met dit algoritme is veel te sneller in vergelijking met de andere sorteeralgoritmen en daarom is het snel sorteren genoemd. Quicksort is het enige algoritme dat leidt tot het verdelen van de array totdat alle waarden in de afzonderlijke arrays zijn gescheiden. Ze worden vervolgens toegevoegd of samengevoegd in een enkele array die als de gesorteerde lijst wordt beschouwd.
Code:
#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);
)
)
In de onderstaande uitvoer bevestigde de gebruiker dat ze 6 waarden zullen indienen en een lijst met gesorteerde gegevens zullen vormen. Na het opgeven van de telling zijn de door de gebruiker opgegeven waarden 56, 35, 24, 86, 98, 2. De quicksort is op deze waarden toegepast en de gesorteerde lijst is gegenereerd met de waarde 2, 24, 35, 56, 86, 98.
Output:
4. Sorteren samenvoegen
- Sorteren samenvoegen kan worden gedefinieerd als een ander sorteeralgoritme dat de sortering uitvoert door de array tot het laatst te scheiden wanneer deze in een individuele waarde verandert en ze vervolgens op een manier te aggregeren zodat deze in een gesorteerde array kan veranderen.
- Het proces kost een beetje veel tijd in vergelijking met de andere rivaliserende algoritmen, maar het wordt als behoorlijk efficiënt beschouwd in vergelijking met anderen. Als het gaat om het sorteren van een grote lijst, werkt dit algoritme heel goed en heeft daarom de voorkeur bij het ontwikkelen van de applicatie die de grote lijst moet verwerken.
Code:
#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);
)
Wanneer de bovenstaande code wordt uitgevoerd, wordt de gebruiker eerst gevraagd het aantal elementen op te geven dat hij wil sorteren. Zodra het nummer is verzonden, moeten ze de waarden van gelijke telling opgeven die ze aanvankelijk hebben opgegeven. Nadat de waarden zijn verzonden, houdt het algoritme die waarden in de array en verwerkt het om de array in de gesorteerde array te transformeren. Nadat de array in oplopende volgorde is gesorteerd, wordt de uitvoer aan de gebruiker weergegeven.
Output:
5. Heapsort
- De heap-sortering kan worden gedefinieerd als het sorteeralgoritme dat werkt door het maximale element in de lijst te zoeken en naar de laatste te plaatsen. Het algoritme voert de actie recursief uit totdat de array oplopend wordt gesorteerd.
- Het kost erg veel tijd om het proces te kiezen om de maximale waarde te kiezen en naar de laatste te verplaatsen en daarom wordt het beschouwd als een minder efficiënte sorteerbenadering als het gaat om het sorteren van de grote lijst. Het werkt echter prima met de lijst met een beperkt aantal waarden. Hieronder vindt u de implementatie van dit algoritme in de programmeertaal C samen met de uitvoer.
Code:
#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;
)
)
)
De werking van dit algoritme is hetzelfde als dat van andere sorteeralgoritmen omdat het de lijst ook in oplopende volgorde sorteert. Wanneer de hierboven geschreven code wordt uitgevoerd, moet de gebruiker het aantal waarden opgeven dat wordt gesorteerd. Nadat de waarden zijn verzonden, verwerkt de code ze om de array in de gesorteerde te veranderen. De output zal uiteindelijk worden getoond en het kan worden waargenomen dat de waarden die zijn opgegeven door de gebruiker in oplopende volgorde zijn gesorteerd.
Output:
6. Invoegsortering
- Invoegsortering kan worden gedefinieerd als het sorteeralgoritme dat werkt door de minimumwaarde één voor één aan het begin van de lijst te plaatsen. Dit is een minder efficiënt sorteeralgoritme en niet geschikt bevonden om met de grote lijst om te gaan.
- Deze benadering van het sorteren van het algoritme werkt erg langzaam en heeft meestal niet de voorkeur in een van de toepassingen. Het kan goed werken met de lijst die vrij weinig elementen bevat. Voor de toepassingen die een aantal waarden moeten verwerken, kan dit algoritme worden gebruikt.
Code:
#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;
)
Wanneer het programma wordt uitgevoerd, moet de gebruiker het aantal waarden invoeren dat hij moet sorteren. Daarna worden de door de gebruiker ingevoerde waarden in de array opgeslagen. Ze zullen dan worden verwerkt en door het gebruik van for- en conditiecontrole wordt de minimumwaarde in elke recursie naar het begin verplaatst en eindigt door een gesorteerde array te genereren. De waarden worden aan het einde van het programma aan de gebruiker getoond.
Uitgang:
Conclusie
Het sorteeralgoritme wordt gebruikt om een gesorteerde lijst te genereren. Dit is een normale lijst waarin alle waarden op een bepaalde manier worden gesorteerd. De lijst is heel vaak in de eigenlijke toepassing gebruikt om een aantal functionaliteiten te brengen. In dit artikel hebben we bubbelsortering, selectiesortering en quicksort behandeld, terwijl er verschillende andere algoritmen zijn, zoals samenvoegsortering die ook kunnen worden gebruikt om een gesorteerde lijst te genereren. Van alle sorteeralgoritmen werkt quicksort erg snel en helpt het de lijst zeer snel te sorteren. De programma's die hier worden geschreven, zijn in feite bedoeld om deze sorteeralgoritmen te implementeren met behulp van de programmeertaal C. Als u bereid bent hetzelfde in andere programmeertalen te implementeren, kunt u dezelfde logica gebruiken en het enige dat kan variëren, zijn de syntaxis en trefwoorden.
Aanbevolen artikel
Dit is een handleiding voor Sorteren in C. Hier bespreken we een inleiding in Sorteren in C en verschillende soorten sorteren, samen met voorbeeldcode. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Patronen in C-programmering
- Palindrome in C-programma
- Sorteren samenvoegen in Java
- Inleiding tot sorteren in R
- Inleiding tot sorteren in C ++
- Overzicht van sorteren in PHP
- Heap Sort in Python
- Sorteerfunctie in Python met voorbeelden