Scal N Sortowane listy połączone za pomocą Min Heap

Tutaj celem jest skorzystanie z faktu, że sterta minowa zawsze zwraca najmniejszego członka. Początkowy wpis każdej listy połączonej jest najmniejszym elementem na odpowiednią listę, ponieważ w tej technice wszystkie połączone listy są już sortowane. Korzystamy z tej okoliczności, tworząc minę. Najmniejszy element jest następnie uzyskiwany przez wyodrębnienie górnego elementu (korzenia) minimum. Otrzymujemy najmniejszy element na wszystkich powiązanych listach. Następny element jest następnie dodawany do minimum po zwiększeniu wskaźnika do listy, do której należy świeżo wydobyty element. Nowy element jest pobierany z minimalistki, wskaźnik LISTET, który zawiera go, jest zwiększany, a nowo spiczaste element jest następnie dodawany do minimum. Dopóki minima nie będzie całkowicie pusta, ta operacja jest powtarzana. Pamiętaj, że stale dodajemy elementy, które wyodrębniamy z minimalnej listy oddzielnej, którą przechowujemy.

Elastyczność metody jest kluczową korzyścią. Z kilkoma drobnymi korektami, takie podejście można również zastosować do połączenia n sortowanych tablic. Niektóre inne sposoby tego nie robią, ale takie podejście się powiedzie, nawet jeśli wszystkie powiązane listy nie mają tego samego rozmiaru.

Algorytm:

Najpierw rzućmy okiem na algorytm tej strategii przed użyciem przykładu, aby to wyjaśnić.

1) Utwórz ministerkę i wypełnij go pierwszym elementem z każdej z listach „N”.

2) Powtórz następujące czynności, aż minima jest kompletna pusta:

1. Usuń element sterty min min i dołącz go na liście wyników.
2. Dodaj element do minimalnego, jeśli znajduje się na tej samej listy powiązanej i jest obok elementu, który został wcześniej wyodrębniony.

3) Zwróć adres węzła głównego listy wyników.

Aby lepiej zrozumieć metodę, użyjmy przykładu. Załóżmy, że podano nam następujące linie Linked Listings:

Element (1) tej hoopu minę. W tym przypadku element wyskakujący pochodzi z drugiej listy Linked. Ponieważ zawiera pobliski element (pozycja 7), wskaźnik drugiej listy połączonej jest modyfikowany, aby odnieść się do pozycji 7, a pozycja 7 jest dodawana do minimum. Bieżący wyodrębniony element 1 jest dodawany do końcowej tablicy wyjściowej.

Początkowy element, który jest 2, jest wyskakujący i dołączony do nowo utworzonej listy połączonej. Zatem wskaźnik trzeciej listy połączonej jest zmieniana na punkt na następny element, który to 7. Ten element jest dodawany do minimalnej grupy, ponieważ 2 był członkiem tej powiązanej listy.

Numer 4 jest usuwany z minimum i dodawany do listy powiązanej, która jest końcowym wynikiem listy powiązanej. Do minimalnej grupy dodaje nowy element (6), a wskaźnik pierwszej połączonej listy jest modyfikowana, aby wskazać.

Wynikowa lista linków zawiera teraz wyodrębnioną liczbę 6. Ponieważ element szósty (6) był wcześniej częścią pierwszej listy powiązanej. Jego wskaźnik wskazuje teraz na następujący element (8), a ten element jest dodawany do minimalnego.

Po raz kolejny bierzemy węzeł główny (7) i dodajemy go do minimalnej grupy. Podczas gdy wskaźnik do drugiej listy połączonej jest aktualizowany, do min-heap nie dodaje się żadnych nowych elementów, ponieważ nie ma na drugiej liście Linked.

W takim przypadku numer 7 z trzecie. Aktualizacje są dokonywane do wskaźnika trzeciej listy połączonej, a wartość 29 jest dodawana do minimalnej sterty.

Tym razem wpadniemy na numer 8, przeniesiemy wskaźnik na pierwszą listy połączoną. Ponownie, do minimum nie dodaje się żadnych nowych elementów, ponieważ na pierwszej linii nie pozostało żadne.

Ostatni pozostały element w minimalnej grupie, numer 29, jest usuwany. Wskaźnik do trzeciej linii jest aktualizowany. Ale ponieważ na liście nie ma już nowych elementów, żadne nie są dodawane.

Teraz, gdy minima jest pusta, możemy użyć listy powiązanej, która została wygenerowana jako scalona lista połączona. Jest to ostateczna forma linkowanej listy, która jest wytwarzana przez ten algorytm.

Zrozum pojęcia z kodem i obrazem

Mamy trzy powiązane listy, jak pokazano następująco:

Notatka: Na początku sterta min jest pusta.

Dodajemy pierwsze elementy wszystkich połączonych list do stosu.

dla (int i = 0; i < N; i++)

if (tablica [i] != Null)
Minheap.push (tablica [i]);

Tworzymy wynikającą z linkowanej listy, jak pokazano na obrazie:

struct node *headNode = newNode (0);
struct node *tempnode = headNode;

While pętla jest wykonywana, ponieważ minheap nie jest pusty (rozmiar = 3 (> 0)).

Tutaj wyodrębniamy górny element ze stosu i przypisujemy go do powstałego tempnode.

Górny element (CURT) = 2
Node struct* curr = minheap.szczyt();
Minheap.Muzyka pop();
tempnode-> następny = curr;

Teraz, w tym kodzie, przydzielamy tempNode z całą listy Linked of Top Element. Element 2 jest dołączony do innych połączonych członków listy, co można zobaczyć na poniższym obrazku:

tempNode = tempnode-> następny; TempNode -> 2
curr -> 2

Tak więc na poprzednim obrazie widzimy, że tempNode wskazuje na CURR (górny element).

Teraz, na tym etapie, musimy sprawdzić, czy bieżący element górny ma inny członek listy powiązanej, czy nie. Jeśli nadal istnieje członek, dodajemy ten element do sterty.

if (curr-> następny != Null)
Minheap.push (curr-> następny);

Dodajemy element numer 5 do stosu, ponieważ obecny górny element wynosił 2, a jego następny element to 5.

Znowu postępujemy zgodnie z poprzednimi krokami.

While pętla jest wykonywana, ponieważ minheap nie jest pusty (rozmiar = 3 (> 0)). Tutaj wyodrębniamy górny element ze stosu i przypisujemy go do powstałego tempnode.

Top Element (CURR) = 3
Node struct* curr = minheap.szczyt();
Minheap.Muzyka pop();
tempnode-> następny = curr;

Ponownie, w tym kodzie, przydzielamy tempNode z całą listy Linked of Top Element. Element 3 jest dołączony do innych połączonych członków listy, co widać na następującym obrazie:

tempNode = tempnode-> następny; TempNode -> 3
Curr -> 3

Notatka: Połączona lista wcześniej aktualnego elementu 2 jest zastąpiona przez połączoną listę nowego członka najwyższego.

Ponownie, na tym etapie, sprawdzamy, czy bieżący element najwyższy ma inny członek listy powiązanej, czy nie. Jeśli nadal istnieje członek, dodajemy ten element do stosu.

if (curr-> następny != Null)
Minheap.push (curr-> następny);

Dodajemy element numer 4 do stosu, ponieważ obecny górny element wynosił 3, a jego następny element to 4.

Znowu postępujemy zgodnie z poprzednimi krokami.

While pętla jest wykonywana, ponieważ minheap nie jest pusty (rozmiar = 3 (> 0)).

Tutaj wyodrębniamy górny element ze stosu i przypisujemy go do powstałego tempnode.

Top Element (CURR) = 4
Node struct* curr = minheap.szczyt();
Minheap.Muzyka pop();
tempnode-> następny = curr;

Ponownie, w tym kodzie, przydzielamy tempNode z całą listy Linked of Top Element. Element 4 jest dołączony do innych połączonych członków listy, co widać na następującym obrazie. A także ponownie, na tym etapie, sprawdzamy, czy bieżący element najwyższy ma inny członek listy powiązanej, czy nie. Jeśli nadal istnieje członek, dodajemy ten element do stosu.

tempNode = tempnode-> następny;
if (curr-> następny != Null)
Minheap.push (curr-> następny); TempNode -> 4
Curr -> 4

Dodajemy element numer 6 do stosu, ponieważ bieżący górny element to 4, a jego następny element to 6.

Teraz element 5 jest wstawiany.

TempNode -> 5
Curr -> 5

Teraz element 6 jest wstawiany.

TempNode -> 6
Curr -> 6

Curr (6)-> następny == null, ponieważ żaden element nie jest dostępny po elemencie 6. Więc nic nie jest dodawane do sterty.

Teraz element 7 jest dodawany po elemencie 6.

TempNode -> 7
Curr -> 7

Teraz element 8 jest dodawany po elemencie 7.

TempNode -> 8
Curr -> 8

Teraz element 9 jest dodawany po elemencie 8.

TempNode -> 9
Curr -> 9

Curr (9)-> następny == null, ponieważ żaden element nie jest dostępny po elemencie 9. Więc nic nie jest dodawane do sterty.

Na koniec dodajemy element 10 na liście.

Teraz sterta jest pusta. Tak więc pętla pęka i zwracamy headnode.

Wdrożenie algorytmu sterty do scalania n sortowanych list

#włączać
za pomocą przestrzeni nazw Std;
Node struct
Int Info;
Node struct*następny;
;
Node struct*newNode (int info)
struct node*new_node = new node ();
new_node-> info = info;
new_node-> następny = null;
returnNew_node;

// Funkcja „Porównaj” używana do budowy
// w górę kolejki priorytetowej
struct porównaj
Bool Operator () (
Node struct* a, struct node* b)
zwróć a-> informacje> b-> informacje;

;
// W tej funkcji scalamy n sortowane listy połączone w jedną listę
struct node* merge_n_sorted_linkedLists (struct node* array [], int n)

// priorytet_queue'minheap ”zaimplementowany z funkcją porównywania
kolejka priorytetowa Minheap;
// pchamy wszystkie węzły głowy
// Lista połączona w stos Minheap
for (inti = 0; ifitut = curr;
tempNode = tempnode-> następny;
// Sprawdzanie najwyższego członka Listany nadal dostępny Ornot
if (curr-> następny!= Null)
// Wpychanie następnego węzła górnego węzła do minheap
Minheap.push (curr-> następny);
// Adres węzła głównego wymaganej scalonej listy
returnheadNode-> następny;

// funkcja wyświetlania linkowanej listy
void displayMerGelinKedList (struct node* głowica)
When (głowa != Null)
Cout

int main ()
// N Liczba powiązanych list
int n = 3;
// szereg wskaźników, które przechowują węzły główne listy
Węzeł* tablica [n];
array [0] = newNode (2);
array [0]-> następny = newNode (4);
array [0]-> następny-> następny = newNode (6);
array [0]-> następny-> następny-> następny = newNode (8);
tablica [1] = newNode (3);
tablica [1]-> następniej = newNode (5);
array [1]-> następny-> następny = newNode (7);
tablica [1]-> Next-> następny-> następny = newNode (9);
tablica [2] = newNode (1);
tablica [2]-> następniej = newNode (10);
array [2]-> następny-> następny = newNode (11);
tablica [2]-> Next-> następny-> następny = newNode (12);
struct node* head = merge_n_sorted_linkedLists (tablica, n);
DisplayMerGelinKedList (głowa);
return0;

Wyjście:

Wniosek

Nauczyliśmy się, jak łączyć n sortowane listy połączone w jedną sortowaną listę połączoną w tym artykule. Podaliśmy prosty wizualny przykład, wykorzystując Min Kapt, aby pomóc Ci zrozumieć ten pomysł. Następnie wyjaśniliśmy to również za pomocą kodu i grafiki. Ponieważ minimalna sterta była podstawą tej metody, próbowaliśmy również opisać, jak to działa w tym artykule. Ta metoda ma złożoność czasu O (n.log (k)) gdzie n jest liczbą węzłów na liście, a k to całkowita liczba list.