Merge N Sortierte verknüpfte Listen mit min Heap sortiert

Hier ist das Ziel, davon zu profitieren, dass ein Min-Root-Haufen immer das kleinste Mitglied zurückgibt. Der erste Eintrag jeder verknüpften Liste ist das kleinste Element in seiner entsprechenden Liste, da in dieser Technik alle verknüpften Listen bereits sortiert sind. Wir nutzen diesen Umstand, indem wir ein Min-heap aus dem ursprünglichen Mitglied jeder verknüpften Liste erstellen. Das kleinste Element wird dann erhalten, indem das obere Element (Wurzel) des Min-HEAP extrahiert wird. Wir erhalten das kleinste Element in allen verknüpften Listen dabei. Das nächste Element wird dann dem Min-heap hinzugefügt, nachdem wir den Zeiger auf die Liste erhöht haben, zu der das frisch extrahierte Element gehört. Ein neues Element stammt aus dem Min-heap, dem verknüpften Zeiger der verknüpften Liste. Bis die Minen-Heibe vollständig leer ist, wird diese Operation wiederholt. Denken Sie daran, dass wir kontinuierlich die Elemente hinzufügen, die wir aus dem Min-heap extrahieren, einer separaten Ergebnisliste, die wir halten.

Die Flexibilität der Methode ist ein wichtiger Vorteil. Mit einigen geringfügigen Anpassungen kann dieser Ansatz auch verwendet werden, um die N -sortierten Arrays zu kombinieren. Einige der anderen Möglichkeiten tun dies nicht, aber dieser Ansatz ist auch dann erfolgreich, wenn alle verknüpften Listen nicht gleich groß sind.

Algorithmus:

Schauen wir uns zunächst den Algorithmus für diese Strategie an, bevor wir ein Beispiel zur Klärung verwenden.

1) Erstellen Sie einen Min-HEAP und füllen Sie ihn mit dem ersten Element aus jedem der verknüpften „N“ -Listen aus.

2) Wiederholen Sie die folgenden Aktionen, bis der Min-HEAP vollständig ist:

1. Entfernen Sie das Element des Min-Root Heaps und geben Sie es in die Ergebnisliste ein.
2. Fügen Sie das Element dem Mine-HEAP hinzu, wenn es sich in derselben verknüpften Liste befindet und sich neben dem zuvor extrahierten Element befindet.

3) Geben Sie die Kopfknotenadresse der Ergebnisliste zurück.

Um die Methode besser zu verstehen, verwenden wir ein Beispiel. Nehmen wir an, wir werden die folgenden verknüpften Angebote zur Verfügung gestellt:

Das Element (1) dieses Min-Root-Haufen. In diesem Fall stammt der Punkt, der geplagt wurde. Da es einen nahe gelegenen Element (Punkt 7) enthält, wird der Zeiger der zweiten verlinkten Liste so geändert, dass sie sich auf Element 7 beziehen, und Artikel 7 wird dem Min-HEAP hinzugefügt. Der Strom extrahierte Element 1 wird dem endgültigen Ausgangsarray hinzugefügt.

Das anfängliche Element, das 2 ist. Somit wird der Zeiger der dritten verlinkten Liste geändert, um auf das nächste Element zu verweisen, das 7 ist. Dieses Element wird dem Min-heap hinzugefügt, da 2 ein Mitglied dieser verlinkten Liste war.

Die Nummer 4 wird aus dem Min-heap entfernt und zur verlinkten Liste hinzugefügt, die das endgültige Ergebnis der verknüpften Liste ist. Ein neues Element (6) wird dem Min-heap hinzugefügt, und der Zeiger der ersten verlinkten Liste wird so geändert, dass sie darauf hingewiesen werden.

Die resultierende verknüpfte Liste enthält jetzt die extrahierte Nummer 6. Da Element Six (6) zuvor Teil der ersten verlinkten Liste war. Sein Zeiger zeigt nun auf das folgende Element (8), und dieses Element wird dem Mine-heap hinzugefügt.

Noch einmal nehmen wir den Stammknoten (7) und fügen ihn dem Miner-HEAP hinzu. Während der Zeiger auf die zweite verknüpfte Liste aktualisiert wird, werden dem Min-HEAP keine neuen Elemente hinzugefügt, da in der zweiten verlinkten Liste keine enthalten ist.

In diesem Fall ist die Nummer 7 der dritten verlinkten Liste aus dem Min-HEAP aufgetaucht. Aktualisierungen werden an den Zeiger der dritten verlinkten Liste durchgeführt, und der Wert 29 wird dem Mindesthaufen hinzugefügt.

Dieses Mal werden wir die Nummer 8 einreichen, dann verschieben wir den Zeiger in die erste verlinkte Liste. Auch hier werden dem Min-HEAP keine neuen Elemente hinzugefügt, da in der ersten verlinkten Liste keine mehr vorhanden sind.

Das letzte verbleibende Element im Min-HEAP, Nummer 29, wird entfernt. Der Zeiger auf die dritte verlinkte Liste wird aktualisiert. Da es in der Liste jedoch bereits keine neuen Elemente gibt, werden keine hinzugefügt.

Nachdem der Min-heap leer ist, können wir die verlinkte Liste verwenden, die als zusammengezogene verlinkte Liste generiert wurde. Dies ist die endgültige Form der verlinkten Liste, die von diesem Algorithmus erstellt wird.

Verstehen Sie die Konzepte mit Code und Bild

Wir haben drei verknüpfte Listen, wie im Folgenden gezeigt:

Notiz: Zu Beginn ist der Min -Haufen leer.

Wir fügen die ersten Elemente aller verknüpften Listen in den Stapel hinzu.

für (int i = 0; i < N; i++)

if (Array [i] != Null)
Minheap.Push (Array [i]);

Wir erstellen eine resultierende verknüpfte Liste, wie im Bild gezeigt:

struct node *headnode = newnode (0);
struct node *tempnode = headnode;

Die while -Schleife wird ausgeführt, weil der Mindeap nicht leer ist (Größe = 3 (> 0)).

Hier extrahieren wir das obere Element aus dem Stapel und weisen es dem resultierenden Tempnode zu.

Oberes Element (Curr) = 2
Strukturknoten* Curr = Minheap.Spitze();
Minheap.Pop();
tempnode-> next = curr;

In diesem Code zuordnen wir den Tempnode mit der gesamten verknüpften Liste des Top -Elements zu. Element 2 ist in den anderen verbundenen Listenmitgliedern enthalten, wie im folgenden Bild zu sehen ist:

tempnode = tempnode-> Weiter; Tempnode -> 2
Curr -> 2

Im vorherigen Bild können wir also sehen, dass Tempnode auf das Curr zeigt (Top -Element).

In diesem Schritt müssen wir nun überprüfen, ob das aktuelle Top -Element ein weiteres verknüpftes Listenmitglied hat oder nicht. Wenn es noch ein Mitglied gibt, fügen wir das Element dem Haufen hinzu.

if (Curr-> Weiter != Null)
Minheap.Push (Curr-> Weiter);

Wir fügen den Stapel die Elementnummer 5 hinzu, da das aktuelle obere Element 2 war und sein nächstes Element 5 beträgt.

Auch hier folgen wir den vorherigen Schritten.

Die while -Schleife wird ausgeführt, weil Minheap nicht leer ist (Größe = 3 (> 0)). Hier extrahieren wir das obere Element aus dem Stapel und weisen es dem resultierenden Tempnode zu.

Oberes Element (Curr) = 3
Strukturknoten* Curr = Minheap.Spitze();
Minheap.Pop();
tempnode-> next = curr;

Auch in diesem Code bringen wir den Tempnode mit der gesamten verknüpften Liste des oberen Elements zu. Element 3 ist in den anderen verbundenen Listenmitgliedern enthalten, wie im folgenden Bild zu sehen ist:

tempnode = tempnode-> Weiter; tempnode -> 3
Curr -> 3

Notiz: Die verknüpfte Liste des zuvor aktuellen Top -Elements 2 wird durch die verknüpfte Liste des neuen Top -Mitglieds überschrieben.

In diesem Schritt überprüfen wir erneut, ob das aktuelle Top -Element ein anderes Mitglied des verknüpften Listen hat oder nicht. Wenn es noch ein Mitglied gibt, fügen wir das Element dem Stapel hinzu.

if (Curr-> Weiter != Null)
Minheap.Push (Curr-> Weiter);

Wir fügen dem Stapel die Elementnummer 4 hinzu, da das aktuelle obere Element 3 war und sein nächstes Element 4 beträgt.

Auch hier folgen wir den vorherigen Schritten.

Die while -Schleife wird ausgeführt, weil der Mindeap nicht leer ist (Größe = 3 (> 0)).

Hier extrahieren wir das obere Element aus dem Stapel und weisen es dem resultierenden Tempnode zu.

Top -Element (Curr) = 4
Strukturknoten* Curr = Minheap.Spitze();
Minheap.Pop();
tempnode-> next = curr;

Auch in diesem Code bringen wir den Tempnode mit der gesamten verknüpften Liste des oberen Elements zu. Das Element 4 ist in den anderen verbundenen Listenmitgliedern enthalten, wie im folgenden Bild zu sehen ist. Außerdem überprüfen wir in diesem Schritt wieder. Wenn es noch ein Mitglied gibt, fügen wir das Element dem Stapel hinzu.

tempnode = tempnode-> Weiter;
if (Curr-> Weiter != Null)
Minheap.Push (Curr-> Weiter); tempnode -> 4
Curr -> 4

Wir fügen dem Stapel die Elementnummer 6 hinzu, da das aktuelle obere Element 4 war und sein nächstes Element 6 beträgt.

Jetzt wird Element 5 eingefügt.

tempnode -> 5
Curr -> 5

Jetzt wird Element 6 eingefügt.

tempnode -> 6
Curr -> 6

Curr (6)-> Weiter == NULL Da nach dem Element 6 kein Element verfügbar ist. Also wird dem Haufen nichts hinzugefügt.

Jetzt wird Element 7 nach Element 6 hinzugefügt.

tempnode -> 7
Curr -> 7

Jetzt wird Element 8 nach Element 7 hinzugefügt.

tempnode -> 8
Curr -> 8

Jetzt wird Element 9 nach Element 8 hinzugefügt.

tempnode -> 9
Curr -> 9

Curr (9)-> Weiter == NULL Da nach dem Element 9 kein Element verfügbar ist. Also wird dem Haufen nichts hinzugefügt.

Schließlich fügen wir das Element 10 in die Liste hinzu.

Jetzt ist der Haufen leer. Also bricht die Schleife und wir geben den Headnode zurück.

Implementierung des HEAP -Algorithmus zum Zusammenführen der N -sortierten Listen

#enthalten
Verwenden von Namespace STD;
Strukturknoten
int info;
Strukturknoten*Weiter;
;
struct node*newnode (int info)
struct node*new_node = new node ();
new_node-> info = info;
new_node-> next = null;
returnNew_node;

// "Vergleiche" -Funktion zum Erstellen verwendet
// in die Prioritätswarteschlange steigen
struktur vergleichen
Bool -Operator () () () () () () () () () () () ()
Struct Node* A, Struct Node* b)
Rückgabe a-> info> b-> info;

;
// In dieser Funktion werden wir die verknüpften Listen in eine Liste zusammenführen
struct node* merge_n_sorted_linkedlists (struct node* array [], int n)

// Priority_queue'minheap 'mit der Vergleichsfunktion implementiert
Prioritätswarteschlange Minheap;
// Wir drücken alle Kopfknoten der
// verlinkte Liste in Minheap Stack
für (inti = 0; inext = curr;
tempnode = tempnode-> Weiter;
// Top Listany -Mitglied noch verfügbar sein noch verfügbarer Ornot
if (Curr-> Weiter!= Null)
// den nächsten Knoten des oberen Knotens in den Mindeap drücken
Minheap.Push (Curr-> Weiter);
// Adresse des Kopfknotens der erforderlichen zusammengeführten Liste
returnheadnode-> Weiter;

// Funktion zur Anzeige der verknüpften Liste
void displayMergelinkedlist (Strukturknoten* Kopf)
während (Kopf != Null)
Cout

int main ()
// n Anzahl der verknüpften Listen
int n = 3;
// eine Reihe von Zeigern, die die Kopfknoten der verknüpften Liste speichern
Knoten* Array [n];
Array [0] = newnode (2);
Array [0]-> next = newnode (4);
Array [0]-> Weiter-> next = newnode (6);
Array [0]-> Weiter-> Weiter-> next = newnode (8);
Array [1] = newnode (3);
Array [1]-> next = newnode (5);
Array [1]-> Weiter-> next = newnode (7);
Array [1]-> Weiter-> Weiter-> next = newnode (9);
Array [2] = newnode (1);
Array [2]-> next = newnode (10);
Array [2]-> Weiter-> next = newnode (11);
Array [2]-> Weiter-> Weiter-> next = newnode (12);
struct node* head = merge_n_sorted_linkedlists (Array, n);
displayMergelinkedList (Kopf);
return0;

Ausgang:

Abschluss

Wir haben gelernt, wie man die verlinkten Listen mit N -sortierten Listen in einer einzigen sortierten verknüpften Liste in diesem Artikel kombiniert. Wir haben ein einfaches visuelles Beispiel geliefert, indem wir den Min -Haufen nutzen, um diese Idee zu verstehen. Danach haben wir es auch mit Code und Grafik erklärt. Da der Mindesthaufen die Grundlage dieser Methode war, haben wir auch versucht zu beschreiben, wie sie in diesem Artikel funktioniert. Diese Methode hat eine zeitliche Komplexität von O (n).Protokoll (k)) wobei n die Anzahl der Knoten in der Liste ist und k die Gesamtzahl der Listen ist.