Einführung in das Sortieren in C
In der Anwendung verspüren die Entwickler den Drang, die Daten zu sortieren, um bestimmte Funktionen einbringen zu können. Es gibt verschiedene Ansätze, um die Daten zu sortieren, und sie werden gemäß der Nomenklatur unter Sortieren gezählt. Die Sortierung kann als das Verfahren zum Anordnen der Daten in einer bestimmten Weise definiert werden, die einer bestimmten Reihenfolge folgt. In diesem Abschnitt erfahren Sie, wie Sie mit der Programmiersprache C sortieren. Es gibt verschiedene Arten der Sortierung, wie die Blasensortierung, Zusammenführungssortierung, Auswahlsortierung, Einfügesortierung und so weiter. Wir werden das eigentliche Codieren für die Sortiermethoden durchführen, die in der Anwendung sehr häufig verwendet werden. Die Codes stehen Ihnen in einem Textformat zur Verfügung, damit Sie diesen Code leicht verwenden können, während die Ausgabe im Screenshot angezeigt wird, um Ihnen einen Einblick in die tatsächliche Ausgabe zu geben, die nach dem Ausführen des Programms erfolgt.
Wie wird in C sortiert?
- Das Sortieren kann basierend auf dem Sortieralgorithmus auf verschiedene Arten durchgeführt werden. In der Programmiersprache C gibt es verschiedene Ansätze, um die Liste zu sortieren. Der Begriff Sortieren bezeichnet die Anordnung von Daten in einer bestimmten Art und Weise, üblicherweise in aufsteigender Reihenfolge. Obwohl die Art und Weise, die Daten zu sortieren, bei allen Sortieralgorithmen unterschiedlich ist, ist das Ergebnis bei allen gleich.
- Normalerweise sucht das Programm beim Sortieren nach der Mindestanzahl und verschiebt diese an den Anfang der Liste und wiederholt die gleichen Suchvorgänge. Sobald die andere kleine Zahl angetroffen wird, wird sie direkt nach dem ersten Index auf die nächste Stelle in der Liste verschoben, und dieser Vorgang wird so lange wiederholt, bis die Sortierliste erhalten wird. So wird in der Programmiersprache C sortiert.
- Bei allen Ansätzen zum Sortieren der Liste spielt das Array in der Programmiersprache C eine sehr wichtige Rolle. In jedem Algorithmus wurde das Array verwendet, um die Liste der zu sortierenden Elemente zu speichern. Beispielsweise werden bei der Blasensortierung die Elemente im einzelnen Array gespeichert und die Werte im Array wurden verarbeitet, um sie in eine Liste sortierter Daten zu konvertieren.
- Bei der Auswahlsortierung wurde dasselbe Array als zwei Arrays behandelt, wobei das erste Array als frei betrachtet wird, um die sortierten Werte mitzuteilen, während das zweite Array die unsortierte Liste enthält. Um das Array sortieren zu können, wird es häufig verwendet, anstatt die Werte in einzelnen Variablen zu speichern. Unter allen Algorithmen arbeitet die schnelle Sortierung sehr schnell und wird daher als schnelle Sortierung bezeichnet. Im Vergleich zu den anderen Sortieralgorithmen ist der Zeitaufwand erheblich geringer.
Sortierarten in C
1. Bubble Sort
- Die Blasensortierung kann als Sortieralgorithmus definiert werden, der dem Ansatz folgt, den Wert im ersten Index durch den kleinsten Wert im Array zu ersetzen und ihn so lange zu wiederholen, bis die Liste sortiert ist. Dies ist eine sehr einfache Methode zum Sortieren. Damit das Array sortiert werden kann, muss der Wert zu Beginn dem Array zugewiesen werden, bevor mit dem Sortieren begonnen wird.
- Unten finden Sie das Programm zum Sortieren des Arrays mithilfe der Blasensortierung, wobei die Werte vom Benutzer übernommen wurden. Sobald das Programm kompiliert und ausgeführt wurde, fragt es den Benutzer nach der Anzahl der Elemente, die sortiert werden sollen. Sobald die Nummer eingegeben wurde, fordert das Programm den Benutzer auf, Werte einzugeben, die der von ihm eingegebenen Anzahl entsprechen. Die Werte werden im Array gespeichert und unter Verwendung der verschachtelten for-Schleife zusammen mit der Entscheidungsfindung mit "if" weiter verarbeitet, um das Array zu sortieren.
- Der erste kleinste im Array gefundene Wert wurde in den ersten Index des Arrays verschoben, und die Suche beginnt erneut, um die andere kleinste Zahl zu finden. Sobald die nächstkleinere Zahl gefunden wurde, ersetzt sie den Wert im zweiten Index und der Vorgang wird so lange wiederholt, bis das Array aus einer sortierten Liste von Werten besteht.
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;
)
Der Benutzer hat die Eingabe 5 3 60 14 1 2 645 übermittelt. Der Algorithmus wurde auf das Array angewendet, das aus Werten in der vom Benutzer angegebenen Weise besteht. Nach der Verarbeitung lautet die empfangene Ausgabe 1 2 3 5 14 60 645 .
Ausgabe:
2. Auswahl sortieren
- Die Auswahlsortierung kann als ein anderer Algorithmus zum Sortieren der Liste definiert werden, in der das Array in zwei Arrays aufgeteilt ist, wobei das erste Array leer sein soll, während das zweite Array aus der nicht sortierten Liste von Werten besteht. Das Programm sucht nach den kleinsten Werten im zweiten Array. Wenn der Wert gefunden wurde, wurde er an den Anfang des ersten Arrays verschoben, das leer war. Die Annäherung wird erneut wiederholt und die nächstkleineren Werte werden zum zweiten Index des ersten Arrays verschoben. Die Prozesse werden so lange wiederholt, bis das zweite Array leer ist.
- Das folgende Programm ist die Codierungsimplementierung des Auswahlsortieralgorithmus. Sobald das Programm erfolgreich ausgeführt wurde, fordert es den Benutzer auf, die Anzahl der Werte einzugeben, die sortiert werden sollen. Sobald der Zählerstand erreicht ist, fordert das Programm den Benutzer auf, die Werte für das zu sortierende Array einzugeben. Der Wert wird dann mit einer verschachtelten for-Schleife verarbeitet, um die Zahlen zu sortieren. Auch hier wurde die Prüfung der if-Bedingung durchgeführt, um die kleinste Zahl zu prüfen.
- Die Vorgänge werden wiederholt, bis die erste Liste mit der sortierten Liste gefüllt ist. Währenddessen behalten die Programme ihren primären Fokus bei, um zu überprüfen, ob das zweite Array einen Wert aufweist, und wenn es als positiv befunden wird, führt das Programm den Sortieralgorithmus erneut aus. Obwohl die Liste auf einfache Weise sortiert wird, kann es im Vergleich zu den anderen Algorithmen etwas länger dauern. Am Ende ist das Ergebnis jedoch dasselbe wie bei den anderen Sortieralgorithmen.
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();
)
Auf die Frage nach der Anzahl der Elemente, die sortiert werden müssen, hat der Benutzer in der folgenden Ausgabe 6 angegeben. Später wurden folgende Werte eingegeben: 25 65 36 86 96 45. Diese Werte werden in dem Array gespeichert, das voraussichtlich in zwei Arrays aufgeteilt wird, wobei eines leer ist, um die sortierte Liste zu speichern, und das andere die unsortierte Liste enthält . Nach dem Verarbeiten der Eingabe lautete das Ergebnis 25 36 45 65 86 96. Dieser Verlust wurde mithilfe der Auswahlsortierung sortiert. Sobald alle sechs Werte in der sortierten Form in das erste Array verschoben wurden, wird das zweite Array leer und der Algorithmus wird beendet.
Ausgabe:
3. Schnelle Sortierung
- Quicksort kann als der andere Algorithmus zum Sortieren der Liste definiert werden, in der das Array nach Werten unterteilt werden soll, die größer oder kleiner sind, bis die gesamten Werte in einzelne Formulare unterteilt sind. In diesem Algorithmus wurde der Wert des letzten Index des Arrays als Pivot ausgewählt, und alle Werte, die kleiner als Pivot sind, wurden in das Array verschoben, von dem erwartet wird, dass es links neben dem Wert und den Elementen mit einem höheren Wert auftritt dann werden die Pivots auf das rechte Array verschoben. Wieder wird ein Drehpunkt aus dem neu gebildeten Array ausgewählt, dessen Werte kleiner als der letzte Drehpunktwert waren. In ähnlicher Weise werden die Werte, die kleiner als der neue Drehpunkt sind, in das linke Array verschoben, und die Werte, die größer als der neue Drehpunkt sind, werden in das rechte Array verschoben.
- Das folgende Programm ist die QuickSort-Implementierung mit der Programmiersprache C. Sobald das Programm ausgeführt wird, fragt es den Benutzer nach der Anzahl der Elemente, die sortiert werden sollen. Basierend auf der Anzahl iteriert die for-Schleife die geschätzten Zeiten, um die Eingabe vom Benutzer zu übernehmen. Die Eingabe wird unter Verwendung der if-Bedingungen zusammen mit der for-Schleife verarbeitet, um eine sortierte Liste zu erstellen. Das Array ordnet die Werte weiterhin mit dem Pivot-Wert an, bis alle Werte auf den kleinsten Wert überprüft wurden.
- Die mit diesem Algorithmus durchgeführte Sortierung ist im Vergleich zu den anderen Sortieralgorithmen viel zu schnell und wurde deshalb als schnelle Sortierung bezeichnet. Quicksort ist der einzige Algorithmus, der zur Aufteilung des Arrays führt, bis alle Werte in die einzelnen Arrays aufgeteilt sind. Sie werden dann zu einem einzigen Array hinzugefügt oder zusammengefasst, das als sortierte Liste betrachtet wird.
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 der folgenden Ausgabe bestätigte der Benutzer, dass er 6 Werte übermitteln und eine Liste sortierter Daten erstellen wird. Nach der Eingabe des Zählwerts sind die vom Benutzer angegebenen Werte 56, 35, 24, 86, 98, 2. Die Quicksortierung wurde auf diese Werte angewendet und die sortierte Liste mit dem Wert 2, 24, 35, 56 erstellt 86, 98.
Ausgabe:
4. Sortieren zusammenführen
- Zusammenführungssortierung kann als ein anderer Sortieralgorithmus definiert werden, der die Sortierung durch Trennen des Arrays bis zum letzten Mal durchführt, bis es sich in einen einzelnen Wert verwandelt, und diese dann so aggregiert, dass es sich in ein sortiertes Array verwandelt.
- Der Prozess nimmt im Vergleich zu den anderen Algorithmen der Konkurrenz ein wenig Zeit in Anspruch, wird jedoch im Vergleich zu anderen als ziemlich effizient angesehen. Wenn es um das Sortieren einer großen Liste geht, funktioniert dieser Algorithmus sehr gut und wird daher bei der Entwicklung der Anwendung bevorzugt, die die große Liste verarbeiten muss.
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);
)
Wenn der obige Code ausgeführt wird, fordert er den Benutzer zunächst auf, die Anzahl der Elemente anzugeben, die sortiert werden sollen. Sobald die Nummer übermittelt wurde, müssen sie die Werte mit der gleichen Anzahl angeben, die sie ursprünglich angegeben haben. Sobald die Werte übermittelt wurden, speichert der Algorithmus diese Werte im Array und verarbeitet sie, um das Array in das sortierte Array umzuwandeln. Nachdem das Array in aufsteigender Reihenfolge sortiert wurde, wird die Ausgabe dem Benutzer angezeigt.
Ausgabe:
5. Heapsort
- Die Heap-Sortierung kann als Sortieralgorithmus definiert werden, bei dem das maximale Element in der Liste durchsucht und bis zum letzten Element platziert wird. Der Algorithmus führt die Aktion rekursiv aus, bis das Array aufsteigend sortiert ist.
- Es ist sehr zeitaufwändig, den Maximalwert auszuwählen und ihn auf den letzten Wert zu verschieben, und daher wird er als weniger effizienter Sortieransatz angesehen, wenn es um das Sortieren der großen Liste geht. Es funktioniert jedoch gut mit der Liste, die eine begrenzte Anzahl von Werten hat. Nachfolgend sehen Sie die Implementierung dieses Algorithmus in der Programmiersprache C zusammen mit der Ausgabe.
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;
)
)
)
Die Funktionsweise dieses Algorithmus ist die gleiche wie bei anderen Sortieralgorithmen, da auch die Liste in aufsteigender Reihenfolge sortiert wird. Wenn der oben beschriebene Code ausgeführt wird, muss der Benutzer die Anzahl der zu sortierenden Werte übermitteln. Sobald die Werte übermittelt wurden, verarbeitet der Code sie, um das Array in das sortierte zu verwandeln. Die Ausgabe wird schließlich angezeigt und es kann beobachtet werden, dass die vom Benutzer übermittelten Werte in aufsteigender Reihenfolge sortiert wurden.
Ausgabe:
6. Einfügesortierung
- Einfügesortierung kann als Sortieralgorithmus definiert werden, bei dem der Mindestwert am Anfang der Liste nacheinander verschoben wird. Dies ist ein weniger effizienter Sortieralgorithmus, der nicht für die Bewältigung der großen Liste geeignet ist.
- Dieser Ansatz zum Sortieren des Algorithmus arbeitet sehr langsam und wird normalerweise in keiner der Anwendungen bevorzugt. Es kann gut mit der Liste funktionieren, die ziemlich wenige Elemente enthält. Bei Anwendungen, bei denen einige wenige Werte verarbeitet werden müssen, kann dieser Algorithmus genutzt werden.
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;
)
Wenn das Programm ausgeführt wird, muss der Benutzer die Anzahl der zu sortierenden Werte eingeben. Danach werden die vom Benutzer eingegebenen Werte im Array gespeichert. Sie werden dann verarbeitet und durch die Verwendung von for-Schleifen- und Bedingungsüberprüfung wird der Minimalwert in jeder Rekursion an den Anfang verschoben und endet mit der Generierung eines sortierten Arrays. Die Werte werden dem Benutzer am Ende des Programms angezeigt.
Ausgabe :
Fazit
Der Sortieralgorithmus wird verwendet, um eine sortierte Liste zu erzeugen, die eine normale Liste ist, in der alle Werte auf eine bestimmte Weise sortiert sind. Die Liste wurde in der aktuellen Anwendung sehr oft verwendet, um einige Funktionen bereitzustellen. In diesem Artikel haben wir Blasensortierung, Auswahlsortierung und Quicksortierung behandelt, während es verschiedene andere Algorithmen gibt, z. B. das Sortieren durch Zusammenführen, die zum Generieren einer sortierten Liste verwendet werden können. Unter allen Sortieralgorithmen arbeitet quicksort sehr schnell und hilft, die Liste sehr schnell zu sortieren. Die hier geschriebenen Programme dienen im Wesentlichen dazu, diese Sortieralgorithmen mit der Programmiersprache C zu implementieren. Wenn Sie bereit sind, dasselbe in anderen Programmiersprachen zu implementieren, können Sie dieselbe Logik verwenden, und das einzige, was variieren kann, können die Syntax und die Schlüsselwörter sein.
Empfohlener Artikel
Dies war eine Anleitung zum Sortieren in C. Hier wird eine Einführung in das Sortieren in C und verschiedene Arten des Sortierens zusammen mit Beispielcode erläutert. Sie können auch unsere anderen Artikelvorschläge durchgehen, um mehr zu erfahren -
- Muster in der C-Programmierung
- Palindrom im C-Programm
- Sortieren in Java zusammenführen
- Einführung in das Sortieren in R
- Einführung in das Sortieren in C ++
- Übersicht über das Sortieren in PHP
- Heap-Sortierung in Python
- Sortierfunktion in Python mit Beispielen