introduction sorting techniques c
Liste der verschiedenen Sortiertechniken in C ++.
Das Sortieren ist eine Technik, die implementiert wird, um die Daten in einer bestimmten Reihenfolge anzuordnen. Eine Sortierung ist erforderlich, um sicherzustellen, dass die von uns verwendeten Daten in einer bestimmten Reihenfolge vorliegen, damit wir die erforderlichen Informationen problemlos aus dem Datenstapel abrufen können.
Wenn die Daten ungepflegt und unsortiert sind und wir eine bestimmte Information wünschen, müssen wir sie jedes Mal einzeln durchsuchen, um die Daten abzurufen.
=> Lesen Sie die Easy C ++ - Schulungsserie durch.
Daher ist es immer ratsam, unsere Daten in einer bestimmten Reihenfolge anzuordnen, damit das Abrufen von Informationen sowie andere an den Daten durchgeführte Vorgänge einfach und effizient durchgeführt werden können.
Wir speichern Daten in Form von Aufzeichnungen. Jeder Datensatz besteht aus einem oder mehreren Feldern. Wenn jeder Datensatz einen eindeutigen Wert für ein bestimmtes Feld hat, nennen wir es ein Schlüsselfeld. Zum Beispiel, In einer Klasse kann Roll No ein eindeutiges oder Schlüsselfeld sein.
die beste kostenlose Musik-Downloader-App für Android
Wir können die Daten nach einem bestimmten Schlüsselfeld sortieren und sie dann in aufsteigender / aufsteigender Reihenfolge oder in absteigender / absteigender Reihenfolge anordnen.
In ähnlicher Weise besteht in einem Telefonwörterbuch jeder Datensatz aus dem Namen einer Person, der Adresse und der Telefonnummer. In diesem Fall ist die Telefonnummer ein eindeutiges oder Schlüsselfeld. Wir können die Daten des Wörterbuchs in diesem Telefonfeld sortieren. Alternativ können wir Daten auch numerisch oder alphanumerisch sortieren.
Wenn wir die zu sortierenden Daten im Hauptspeicher selbst anpassen können, ohne dass ein weiterer Hilfsspeicher erforderlich ist, nennen wir sie als Interne Sortierung .
Wenn wir andererseits einen Hilfsspeicher zum Speichern von Zwischendaten während des Sortierens benötigen, nennen wir die Technik als Externe Sortierung .
In diesem Tutorial lernen wir die verschiedenen Sortiertechniken in C ++ im Detail kennen.
Was du lernen wirst:
Sortiertechniken in C ++
C ++ unterstützt verschiedene Sortiertechniken, wie unten aufgeführt.
Blasensortierung
Die Blasensortierung ist die einfachste Technik, bei der wir jedes Element mit dem benachbarten Element vergleichen und die Elemente austauschen, wenn sie nicht in Ordnung sind. Auf diese Weise wird am Ende jeder Iteration (Pass genannt) das schwerste Element am Ende der Liste gesprudelt.
Im Folgenden finden Sie ein Beispiel für die Blasensortierung.
Zu sortierendes Array:
Wie oben gezeigt, haben wir es geschafft, in wenigen Durchgängen ein vollständig sortiertes Array zu erhalten, da es sich um ein kleines Array handelt, das fast sortiert wurde.
Lassen Sie uns die Blasensortiertechnik in C ++ implementieren.
#include using namespace std; int main () { int i, j,temp; int a(5) = {10,2,0,43,12}; cout <<'Input list ...
'; for(i = 0; i<5; i++) { cout < Ausgabe:
Eingabeliste…
10 2 0 43 12
Liste sortierter Elemente…
0 2 10 12 43
Wie aus der Ausgabe ersichtlich, wird bei der Blasensortiertechnik bei jedem Durchgang das schwerste Element bis zum Ende des Arrays gesprudelt, wodurch das Array vollständig sortiert wird.
Auswahl Sortieren
Es ist einfach, aber leicht, eine Technik zu implementieren, bei der wir das kleinste Element in der Liste finden und an der richtigen Stelle platzieren. Bei jedem Durchgang wird das nächstkleinere Element ausgewählt und an der richtigen Position platziert.
Nehmen wir das gleiche Array wie im vorherigen Beispiel und führen Sie eine Auswahlsortierung durch, um dieses Array zu sortieren.
Wie in der obigen Abbildung gezeigt, benötigen wir für N Anzahl von Elementen N-1 Durchgänge, um das Array vollständig zu sortieren. Am Ende jedes Durchlaufs wird das kleinste Element im Array an der richtigen Position im sortierten Array platziert.
Als nächstes implementieren wir die Auswahlsortierung mit C ++.
#include using namespace std; int findSmallest (int(),int); int main () { int myarray(5) = {12,45,8,15,33}; int pos,temp; cout<<'
Input list of elements to be Sorted
'; for(int i=0;i<5;i++) { cout< Ausgabe:
Geben Sie eine Liste der zu sortierenden Elemente ein
12 45 8 15 33
Sortierte Liste von Elementen ist
8 12 15 33 45
Bei der Auswahlsortierung wird bei jedem Durchgang das kleinste Element im Array an der richtigen Position platziert. Daher erhalten wir am Ende des Sortiervorgangs ein vollständig sortiertes Array.
Sortieren durch Einfügen
Die Einfügesortierung ist eine Technik, bei der wir mit dem zweiten Element der Liste beginnen. Wir vergleichen das zweite Element mit seinem vorherigen (1st) Element und platzieren Sie es an der richtigen Stelle. Im nächsten Durchgang vergleichen wir jedes Element mit allen vorherigen Elementen und fügen es an der richtigen Stelle ein.
Die obigen drei Sortiertechniken sind einfach und leicht zu implementieren. Diese Techniken funktionieren gut, wenn die Listengröße kleiner ist. Da die Liste größer wird, arbeiten diese Techniken nicht so effizient.
Die Technik wird durch das Verständnis der folgenden Abbildung klar.
Das zu sortierende Array lautet wie folgt:
Jetzt vergleichen wir für jeden Durchgang das aktuelle Element mit allen vorherigen Elementen. Im ersten Durchgang beginnen wir also mit dem zweiten Element.
Wir benötigen also N Durchgänge, um ein Array mit N Elementen vollständig zu sortieren.
Implementieren wir die Insertion Sort-Technik mit C ++.
#include using namespace std; int main () { int myarray(5) = { 12,4,3,1,15}; cout<<'
Input list is
'; for(int i=0;i<5;i++) { cout < Ausgabe:
Eingabeliste ist
12 4 3 1 15
Sortierte Liste ist
1 3 4 12 15
Die obige Ausgabe zeigt das vollständig sortierte Array mithilfe der Einfügesortierung.
Schnelle Sorte
Quicksort ist der effizienteste Algorithmus, mit dem die Daten sortiert werden können. Diese Technik verwendet die Strategie „Teilen und Erobern“, bei der das Problem in mehrere Teilprobleme unterteilt wird und nach dem Lösen dieser Teilprobleme einzeln zu einer vollständigen sortierten Liste zusammengeführt werden.
In Quicksort teilen wir zuerst die Liste um das Pivot-Element und platzieren dann die anderen Elemente an den richtigen Positionen entsprechend dem Pivot-Element.
Wie in der obigen Abbildung gezeigt, teilen wir bei der Quicksort-Technik das Array so um ein Pivot-Element, dass sich alle Elemente, die kleiner als der Pivot sind, links davon befinden, die Elemente, die größer als der Pivot sind, rechts davon. Dann nehmen wir diese beiden Arrays unabhängig voneinander auf und sortieren sie und verbinden oder erobern sie, um ein resultierendes sortiertes Array zu erhalten.
Der Schlüssel zu Quicksort ist die Auswahl des Pivot-Elements. Es kann das erste, letzte oder mittlere Element des Arrays sein. Der erste Schritt nach Auswahl des Pivot-Elements besteht darin, den Pivot an der richtigen Position zu platzieren, damit wir das Array entsprechend teilen können.
Lassen Sie uns die Quick Sort-Technik mit C ++ implementieren.
#include using namespace std; // Swap two elements - Utility function void swap(int* a, int* b) { int t = *a; *a = *b; *b = t; } // partition the array using last element as pivot int partition (int arr(), int low, int high) { int i = (low - 1); for (int j = low; j <= high- 1; j++) { //if current element is smaller than pivot, increment the low element //swap elements at i and j if (arr(j) <= pivot) { i++; // increment index of smaller element swap(&arr(i), &arr(j)); } } swap(&arr(i + 1), &arr(high)); return (i + 1); } //quicksort algorithm void quickSort(int arr(), int low, int high) { if (low < high) { //partition the array int pivot = partition(arr, low, high); //sort the sub arrays independently quickSort(arr, low, pivot - 1); quickSort(arr, pivot + 1, high); } } void displayArray(int arr(), int size) { int i; for (i=0; i < size; i++) cout< Ausgabe:
Eingabearray
12 23 3 43 51
Array sortiert mit Quicksort
3 12 23 43 51
In der obigen QuickSort-Implementierung haben wir eine Partitionsroutine, die verwendet wird, um das Eingabearray um ein Pivot-Element zu partitionieren, das das letzte Element im Array ist. Dann rufen wir die Quicksort-Routine rekursiv auf, um die Sub-Arrays wie in der Abbildung gezeigt einzeln zu sortieren.
Zusammenführen, sortieren
Dies ist eine weitere Technik, die die Strategie „Teilen und Erobern“ verwendet. Bei dieser Technik teilen wir die Liste zuerst in gleiche Hälften. Anschließend führen wir unabhängig voneinander eine Zusammenführungssortiertechnik für diese Listen durch, sodass beide Listen sortiert werden. Schließlich führen wir beide Listen zusammen, um eine vollständige sortierte Liste zu erhalten.
Zusammenführungssortierung und schnelle Sortierung sind schneller als die meisten anderen Sortiertechniken. Ihre Leistung bleibt auch dann erhalten, wenn die Liste größer wird.
Lassen Sie uns eine Illustration der Merge Sort-Technik sehen.
In der obigen Abbildung sehen wir, dass die Zusammenführungssortiertechnik das ursprüngliche Array wiederholt in Subarrays unterteilt, bis nur noch ein Element in jedem Subarray vorhanden ist. Sobald dies erledigt ist, werden die Subarrays unabhängig voneinander sortiert und zu einem vollständig sortierten Array zusammengeführt.
Als nächstes implementieren wir Merge Sort in C ++.
#include using namespace std; void merge(int *,int, int , int ); void merge_sort(int *arr, int low, int high) { int mid; if (low num; cout<<'Enter '<myarray(i); } merge_sort(myarray, 0, num-1); cout<<'Sorted array
'; for (int i = 0; i < num; i++) { cout< Ausgabe:
Geben Sie die Anzahl der zu sortierenden Elemente ein: 5
Geben Sie 5 zu sortierende Elemente ein: 10 21 47 3 59
Sortiertes Array
3 10 21 47 59
Shell Sort
Die Shell-Sortierung ist eine Erweiterung der Einfügesortiertechnik. Bei der Einfügesortierung wird nur das nächste Element behandelt, während bei der Shell-Sortierung ein Inkrement oder eine Lücke bereitgestellt wird, mit der wir kleinere Listen aus der übergeordneten Liste erstellen. Die Elemente in den Unterlisten müssen nicht zusammenhängend sein, sondern sind normalerweise „gap_value“ voneinander entfernt.
Die Shell-Sortierung ist schneller als die Einfügungssortierung und erfordert weniger Bewegungen als die Einfügungssortierung.
Wenn wir eine Lücke von angeben, haben wir die folgenden Unterlisten mit jedem Element, das 3 Elemente voneinander entfernt ist.
Wir sortieren dann diese drei Unterlisten.
Das obige Array, das wir nach dem Zusammenführen der sortierten Unterarrays erhalten haben, ist nahezu sortiert. Jetzt können wir eine Einfügesortierung für dieses Array durchführen, um das gesamte Array zu sortieren.
Wir sehen also, dass wir die fast sortierte Liste erhalten, sobald wir das Array mit dem entsprechenden Inkrement in Unterlisten aufteilen und sie dann zusammenführen. Die Einfügesortiertechnik in dieser Liste kann ausgeführt werden, und das Array wird in weniger Zügen sortiert als die ursprüngliche Einfügesortierung.
Im Folgenden wird die Implementierung der Shell-Sortierung in C ++ angegeben.
#include using namespace std; // shellsort implementation int shellSort(int arr(), int N) { for (int gap = N/2; gap > 0; gap /= 2) { for (int i = gap; i = gap && arr(j - gap) > temp; j -= gap) arr(j) = arr(j - gap); arr(j) = temp; } } return 0; } int main() { int arr() = {45,23,53,43,18}; //Calculate size of array int N = sizeof(arr)/sizeof(arr(0)); cout << 'Array to be sorted:
'; for (int i=0; i Ausgabe:
Zu sortierendes Array:
45 23 53 43 18
Array nach Shell-Sortierung:
18 23 43 45 53
Die Shell-Sortierung stellt somit eine enorme Verbesserung gegenüber der Einfügungssortierung dar und benötigt nicht einmal die Hälfte der Schritte zum Sortieren des Arrays.
Heap Sort
Heapsort ist eine Technik, bei der die Heap-Datenstruktur (Min-Heap oder Max-Heap) zum Sortieren der Liste verwendet wird. Wir konstruieren zuerst einen Heap aus der unsortierten Liste und verwenden den Heap auch zum Sortieren des Arrays.
Heapsort ist effizient, aber nicht so schnell oder zusammengeführt.
Wie in der obigen Abbildung gezeigt, konstruieren wir zunächst einen maximalen Heap aus den zu sortierenden Array-Elementen. Dann durchqueren wir den Haufen und tauschen das letzte und das erste Element aus. Zu diesem Zeitpunkt ist das letzte Element bereits sortiert. Dann konstruieren wir wieder einen maximalen Heap aus den verbleibenden Elementen.
Durchqueren Sie den Heap erneut, tauschen Sie das erste und das letzte Element aus und fügen Sie das letzte Element zur sortierten Liste hinzu. Dieser Vorgang wird fortgesetzt, bis nur noch ein Element im Heap vorhanden ist, das zum ersten Element der sortierten Liste wird.
Lassen Sie uns nun Heap Sort mit C ++ implementieren.
#include using namespace std; // function to heapify the tree void heapify(int arr(), int n, int root) { int largest = root; // root is the largest element int l = 2*root + 1; // left = 2*root + 1 int r = 2*root + 2; // right = 2*root + 2 // If left child is larger than root if (l arr(largest)) largest = l; // If right child is larger than largest so far if (r arr(largest)) largest = r; // If largest is not root if (largest != root) { //swap root and largest swap(arr(root), arr(largest)); // Recursively heapify the sub-tree heapify(arr, n, largest); } } // implementing heap sort void heapSort(int arr(), int n) { // build heap for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // extracting elements from heap one by one for (int i=n-1; i>=0; i--) { // Move current root to end swap(arr(0), arr(i)); // again call max heapify on the reduced heap heapify(arr, i, 0); } } /* print contents of array - utility function */ void displayArray(int arr(), int n) { for (int i=0; i Ausgabe:
Eingabearray
4 17 3 12 9
Sortiertes Array
3 4 9 12 17
Bisher haben wir alle wichtigen Sortiertechniken kurz mit einer Illustration besprochen. Wir werden jede dieser Techniken in unseren nachfolgenden Tutorials zusammen mit verschiedenen Beispielen im Detail lernen, um jede Technik zu verstehen.
Fazit
Eine Sortierung ist erforderlich, um die Daten sortiert und in der richtigen Reihenfolge zu halten. Unsortiert und ungepflegt kann der Zugriff länger dauern und somit die Leistung des gesamten Programms beeinträchtigen. Daher müssen die Daten für alle Vorgänge im Zusammenhang mit Daten wie Zugriff, Suche, Manipulation usw. sortiert werden.
Bei der Programmierung werden viele Sortiertechniken eingesetzt. Jede Technik kann abhängig von der von uns verwendeten Datenstruktur oder der Zeit, die der Algorithmus zum Sortieren der Daten benötigt, oder dem Speicherplatz, den der Algorithmus zum Sortieren der Daten benötigt, angewendet werden. Die Technik, die wir verwenden, hängt auch davon ab, welche Datenstruktur wir sortieren.
Die Sortiertechniken ermöglichen es uns, unsere Datenstrukturen in einer bestimmten Reihenfolge zu sortieren und die Elemente entweder in aufsteigender oder absteigender Reihenfolge anzuordnen. Wir haben die Sortiertechniken wie die Blasensortierung, die Auswahlsortierung, die Einfügesortierung, die Quicksortierung, die Shell-Sortierung, die Zusammenführungssortierung und die Heap-Sortierung gesehen. Blasensortierung und Auswahlsortierung sind einfacher und einfacher zu implementieren.
In unseren nachfolgenden Tutorials werden wir jede der oben genannten Sortiertechniken im Detail sehen.
=> Klicken Sie hier für den kostenlosen C ++ - Kurs.
Literatur-Empfehlungen
- Heap-Sortierung in C ++ mit Beispielen
- Sortierung in C ++ mit Beispielen zusammenführen
- Einfügungssortierung in C ++ mit Beispielen
- JMeter Video 1: Einführung, Herunterladen und Installieren von JMeter
- Einführung in die Java-Programmiersprache - Video-Tutorial
- Python-Einführungs- und Installationsprozess
- Unix-Sortierbefehl mit Syntax, Optionen und Beispielen
- MongoDB Sort () -Methode mit Beispielen
