what is heap data structure java
In diesem Tutorial wird die Java-Heap-Datenstruktur und verwandte Konzepte wie Min-Heap, Max-Heap, Heap-Sortierung, Stapel gegen Heap anhand von Beispielen erläutert:
Ein Heap ist eine spezielle Datenstruktur in Java. Ein Heap ist eine baumbasierte Datenstruktur und kann als vollständiger Binärbaum klassifiziert werden. Alle Knoten des Heaps sind in einer bestimmten Reihenfolge angeordnet.
=> Besuchen Sie hier, um die Java-Schulungsreihe für alle zu sehen
Was du lernen wirst:
Heap-Datenstruktur in Java
In der Heap-Datenstruktur wird der Wurzelknoten mit seinen untergeordneten Knoten verglichen und gemäß der Reihenfolge angeordnet. Wenn also a ein Wurzelknoten und b sein Kind ist, dann ist die Eigenschaft, Taste (a)> = Taste (b) generiert einen maximalen Heap.
Die obige Beziehung zwischen dem Stammknoten und dem untergeordneten Knoten wird als 'Heap-Eigenschaft' bezeichnet.
Abhängig von der Reihenfolge der Eltern-Kind-Knoten gibt es im Allgemeinen zwei Arten von Heaps:
# 1) Max-Heap ::In einem Max-Heap ist der Wurzelknotenschlüssel der größte aller Schlüssel im Heap. Es sollte sichergestellt werden, dass dieselbe Eigenschaft für alle Teilbäume im Heap rekursiv gilt.
Das folgende Diagramm zeigt einen maximalen Beispielhaufen. Beachten Sie, dass der Stammknoten größer als seine untergeordneten Knoten ist.
# 2) Min-Heap ::Im Fall eines Min-Heaps ist der Wurzelknotenschlüssel der kleinste oder minimale unter allen anderen im Heap vorhandenen Schlüsseln. Wie im Max-Heap sollte diese Eigenschaft in allen anderen Teilbäumen im Heap rekursiv wahr sein.
Ein Beispiel, eines Min-Heap-Baums wird unten gezeigt. Wie wir sehen können, ist der Stammschlüssel der kleinste aller anderen Schlüssel im Heap.
Eine Heap-Datenstruktur kann in folgenden Bereichen verwendet werden:
- Heaps werden hauptsächlich zum Implementieren von Prioritätswarteschlangen verwendet.
- Insbesondere Min-Heap kann verwendet werden, um die kürzesten Pfade zwischen den Scheitelpunkten in einem Diagramm zu bestimmen.
Wie bereits erwähnt, ist die Heap-Datenstruktur ein vollständiger Binärbaum, der die Heap-Eigenschaft für root und die untergeordneten Elemente erfüllt. Dieser Haufen wird auch als bezeichnet binärer Haufen .
Binärer Haufen
Ein binärer Heap erfüllt die folgenden Eigenschaften:
- Ein binärer Heap ist ein vollständiger binärer Baum. In einem vollständigen Binärbaum sind alle Ebenen mit Ausnahme der letzten Ebene vollständig gefüllt. Auf der letzten Ebene sind die Tasten so weit wie möglich links.
- Es erfüllt die Heap-Eigenschaft. Der binäre Heap kann je nach der erfüllten Heap-Eigenschaft Max- oder Min-Heap sein.
Ein binärer Heap wird normalerweise als Array dargestellt. Da es sich um einen vollständigen Binärbaum handelt, kann er leicht als Array dargestellt werden. Somit ist in einer Array-Darstellung eines binären Heaps das Wurzelelement A (0), wobei A das Array ist, das zur Darstellung des binären Heaps verwendet wird.
Also im Allgemeinen für jeden ithKnoten in der binären Heap-Array-Darstellung A (i) können wir die Indizes anderer Knoten wie unten gezeigt darstellen.
| A ((i-1) / 2) | Repräsentiert den übergeordneten Knoten |
|---|---|
| Der Zugriff ist schneller. | Langsamer als der Stapel. |
| A ((2 * i) +1) | Repräsentiert den linken untergeordneten Knoten |
| A ((2 * i) +2) | Repräsentiert den richtigen untergeordneten Knoten |
Betrachten Sie den folgenden binären Heap:
Die Array-Darstellung des obigen minimalen binären Heaps ist wie folgt:
Wie oben gezeigt, wird der Heap gemäß dem durchlaufen Level-Reihenfolge d.h. die Elemente werden auf jeder Ebene von links nach rechts durchlaufen. Wenn die Elemente auf einer Ebene erschöpft sind, fahren wir mit der nächsten Ebene fort.
Als nächstes werden wir den binären Heap in Java implementieren.
Das folgende Programm demonstriert den binären Heap in Java.
import java.util.*; class BinaryHeap { private static final int d= 2; private int() heap; private int heapSize; //BinaryHeap constructor with default size public BinaryHeap(int capacity){ heapSize = 0; heap = new int( capacity+1); Arrays.fill(heap, -1); } //is heap empty? public boolean isEmpty(){ return heapSize==0; } //is heap full? public boolean isFull(){ return heapSize == heap.length; } //return parent private int parent(int i){ return (i-1)/d; } //return kth child private int kthChild(int i,int k){ return d*i +k; } //insert new element into the heap public void insert(int x){ if(isFull()) throw new NoSuchElementException('Heap is full, No space to insert new element'); heap(heapSize++) = x; heapifyUp(heapSize-1); } //delete an element from the heap at given position public int delete(int x){ if(isEmpty()) throw new NoSuchElementException('Heap is empty, No element to delete'); int key = heap(x); heap(x) = heap(heapSize -1); heapSize--; heapifyDown(x); return key; } //maintain heap property during insertion private void heapifyUp(int i) { int temp = heap(i); while(i>0 && temp > heap(parent(i))){ heap(i) = heap(parent(i)); i = parent(i); } heap(i) = temp; } //maintain heap property during deletion private void heapifyDown(int i){ int child; int temp = heap(i); while(kthChild(i, 1) heap(rightChild)?leftChild:rightChild; } //print the heap public void printHeap() { System.out.print('nHeap = '); for (int i = 0; i Ausgabe:
nHeap = 7 4 6 1 3 2 5
Min Heap In Java
Ein Min-Heap in Java ist ein vollständiger Binärbaum. Im Min-Heap ist der Stammknoten kleiner als alle anderen Knoten im Heap. Im Allgemeinen ist der Schlüsselwert jedes internen Knotens kleiner oder gleich seinen untergeordneten Knoten.
In Bezug auf die Array-Darstellung von Min-Heap wird, wenn ein Knoten an Position 'i' gespeichert ist, sein linker untergeordneter Knoten an Position 2i + 1 und dann der rechte untergeordnete Knoten an Position 2i + 2 gespeichert. Die Position (i-1) / 2 gibt ihren übergeordneten Knoten zurück.
Nachfolgend sind die verschiedenen Vorgänge aufgeführt, die von min-heap unterstützt werden.
# 1) Insert (): Zunächst wird am Ende des Baums ein neuer Schlüssel hinzugefügt. Wenn der Schlüssel größer als sein übergeordneter Knoten ist, wird die Heap-Eigenschaft beibehalten. Andernfalls müssen wir den Schlüssel nach oben durchlaufen, um die Heap-Eigenschaft zu erfüllen. Der Einfügevorgang in min heap benötigt O (log n) Zeit.
# 2) extractMin (): Diese Operation entfernt das minimale Element aus dem Heap. Beachten Sie, dass die Heap-Eigenschaft beibehalten werden sollte, nachdem das Root-Element (min-Element) aus dem Heap entfernt wurde. Diese gesamte Operation benötigt O (Logn).
# 3) getMin (): getMin () gibt die Wurzel des Heaps zurück, die auch das minimale Element ist. Dieser Vorgang wird in O (1) -Zeit ausgeführt.
Unten ist ein Beispielbaum für einen Min-Heap angegeben.
Das obige Diagramm zeigt einen Min-Heap-Baum. Wir sehen, dass die Wurzel des Baumes das minimale Element im Baum ist. Da sich die Wurzel an Position 0 befindet, befindet sich ihr linkes Kind bei 2 * 0 + 1 = 1 und das rechte Kind bei 2 * 0 + 2 = 2.
Min Heap Algorithmus
Im Folgenden wird der Algorithmus zum Erstellen eines Min-Heaps angegeben.
procedure build_minheap Array Arr: of size N => array of elements { repeat for (i = N/2 ; i >= 1 ; i--) call procedure min_heapify (A, i); } procedure min_heapify (var A( ) , var i, var N) { var left = 2*i; var right = 2*i+1; var smallest; if(left <= N and A(left) < A( i ) ) smallest = left; else smallest = i; if(right <= N and A(right) < A(smallest) ) smallest = right; if(smallest != i) { swap A( i ) and A( smallest )); call min_heapify (A, smallest,N); } }Min Heap-Implementierung in Java
Wir können den Min-Heap entweder mithilfe von Array- oder Prioritätswarteschlangen implementieren. Das Implementieren von Min-Heap mithilfe von Prioritätswarteschlangen ist die Standardimplementierung, da eine Prioritätswarteschlange als Min-Heap implementiert wird.
Das folgende Java-Programm implementiert den Min-Heap mithilfe von Arrays. Hier verwenden wir die Array-Darstellung für den Heap und wenden dann die Heapify-Funktion an, um die Heap-Eigenschaft jedes dem Heap hinzugefügten Elements beizubehalten. Schließlich zeigen wir den Heap an.
class Min_Heap { private int() HeapArray; private int size; private int maxsize; private static final int FRONT = 1; //constructor to initialize the HeapArray public Min_Heap(int maxsize) { this.maxsize = maxsize; this.size = 0; HeapArray = new int(this.maxsize + 1); HeapArray(0) = Integer.MIN_VALUE; } // returns parent position for the node private int parent(int pos) { return pos / 2; } // returns the position of left child private int leftChild(int pos) { return (2 * pos); } // returns the position of right child private int rightChild(int pos) { return (2 * pos) + 1; } // checks if the node is a leaf node private boolean isLeaf(int pos) { if (pos >= (size / 2) && pos HeapArray(leftChild(pos)) || HeapArray(pos) > HeapArray(rightChild(pos))) { // swap with left child and then heapify the left child if (HeapArray(leftChild(pos)) = maxsize) { return; } HeapArray(++size) = element; int current = size; while (HeapArray(current) = 1; pos--) { minHeapify(pos); } } // remove and return the heap elment public int remove() { int popped = HeapArray(FRONT); HeapArray(FRONT) = HeapArray(size--); minHeapify(FRONT); return popped; } } class Main{ public static void main(String() arg) { //construct a min heap from given data System.out.println('The Min Heap is '); Min_Heap minHeap = new Min_Heap(7); minHeap.insert(12); minHeap.insert(15); minHeap.insert(30); minHeap.insert(40); minHeap.insert(50); minHeap.insert(90); minHeap.insert(45); minHeap.minHeap(); //display the min heap contents minHeap.display(); //display root node of the min heap System.out.println('The Min val(root node):' + minHeap.remove()); } } Ausgabe:
Max Heap In Java
Ein maximaler Heap ist auch ein vollständiger Binärbaum. In einem maximalen Heap ist der Stammknoten größer oder gleich den untergeordneten Knoten. Im Allgemeinen ist der Wert eines internen Knotens in einem maximalen Heap größer oder gleich seinen untergeordneten Knoten.
Während der maximale Heap einem Array zugeordnet ist, wird, wenn ein Knoten an der Position 'i' gespeichert ist, sein linkes Kind bei 2i + 1 und das rechte Kind bei 2i + 2 gespeichert.
Ein typischer Max-Heap sieht wie folgt aus:
Im obigen Diagramm sehen wir, dass der Wurzelknoten der größte im Heap ist und seine untergeordneten Knoten Werte haben, die kleiner als der Wurzelknoten sind.
Ähnlich wie bei Min-Heap kann der Max-Heap auch als Array dargestellt werden.
Wenn also A ein Array ist, das den Max-Heap darstellt, ist A (0) der Wurzelknoten. Wenn A (i) ein beliebiger Knoten im maximalen Heap ist, sind die folgenden benachbarten Knoten die folgenden, die mithilfe eines Arrays dargestellt werden können.
- A ((i-1) / 2) repräsentiert den Elternknoten von A (i).
- A ((2i +1)) repräsentiert den linken untergeordneten Knoten von A (i).
- A (2i + 2) gibt den rechten untergeordneten Knoten von A (i) zurück.
Die Operationen, die auf dem Max Heap ausgeführt werden können, sind unten angegeben.
# 1) Einfügen: Einfügeoperation fügt einen neuen Wert in den Max-Heap-Baum ein. Es wird am Ende des Baumes eingefügt. Wenn der neue Schlüssel (Wert) kleiner als sein übergeordneter Knoten ist, wird die Heap-Eigenschaft beibehalten. Andernfalls muss der Baum gehäuft werden, um die Eigenschaft heap beizubehalten.
Was sind die Stufen von SDLC
Die zeitliche Komplexität der Einfügeoperation beträgt O (log n).
# 2) ExtractMax: Die Operation ExtractMax entfernt das maximale Element (root) aus dem maximalen Heap. Die Operation häuft auch den maximalen Heap an, um die Heap-Eigenschaft beizubehalten. Die zeitliche Komplexität dieser Operation beträgt O (log n).
# 3) getMax: Die getMax-Operation gibt den Wurzelknoten des maximalen Heaps mit der zeitlichen Komplexität von O (1) zurück.
Das folgende Java-Programm implementiert den maximalen Heap. Wir verwenden hier ArrayList, um die maximalen Heap-Elemente darzustellen.
import java.util.ArrayList; class Heap { void heapify(ArrayList hT, int i) { int size = hT.size(); int largest = i; int l = 2 * i + 1; int r = 2 * i + 2; if (l hT.get(largest)) largest = l; if (r hT.get(largest)) largest = r; if (largest != i) { int temp = hT.get(largest); hT.set(largest, hT.get(i)); hT.set(i, temp); heapify(hT, largest); } } void insert(ArrayList hT, int newNum) { int size = hT.size(); if (size == 0) { hT.add(newNum); } else { hT.add(newNum); for (int i = size / 2 - 1; i >= 0; i--) { heapify(hT, i); } } } void deleteNode(ArrayList hT, int num) { int size = hT.size(); int i; for (i = 0; i = 0; j--) { heapify(hT, j); } } void printArray(ArrayList array, int size) { for (Integer i : array) { System.out.print(i + ' '); } System.out.println(); } } class Main{ public static void main(String args()) { ArrayList array = new ArrayList(); int size = array.size(); Heap h = new Heap(); h.insert(array, 3); h.insert(array, 4); h.insert(array, 9); h.insert(array, 5); h.insert(array, 2); System.out.println('Max-Heap array: '); h.printArray(array, size); h.deleteNode(array, 4); System.out.println('After deleting an element: '); h.printArray(array, size); } } Ausgabe:
Priority Queue Min Heap In Java
Die Datenstruktur der Prioritätswarteschlange in Java kann direkt zur Darstellung des Min-Heaps verwendet werden. Standardmäßig implementiert die Prioritätswarteschlange Min-Heap.
Das folgende Programm demonstriert den Min-Heap in Java mithilfe der Prioritätswarteschlange.
import java.util.*; class Main { public static void main(String args()) { // Create priority queue object PriorityQueue pQueue_heap = new PriorityQueue(); // Add elements to the pQueue_heap using add() pQueue_heap.add(100); pQueue_heap.add(30); pQueue_heap.add(20); pQueue_heap.add(40); // Print the head (root node of min heap) using peek method System.out.println('Head (root node of min heap):' + pQueue_heap.peek()); // Print min heap represented using PriorityQueue System.out.println('
Min heap as a PriorityQueue:'); Iterator iter = pQueue_heap.iterator(); while (iter.hasNext()) System.out.print(iter.next() + ' '); // remove head (root of min heap) using poll method pQueue_heap.poll(); System.out.println('
Min heap after removing root node:'); //print the min heap again Iterator iter2 = pQueue_heap.iterator(); while (iter2.hasNext()) System.out.print(iter2.next() + ' '); } } Ausgabe:
Maximaler Heap der Prioritätswarteschlange in Java
Um den maximalen Heap in Java mithilfe der Prioritätswarteschlange darzustellen, müssen wir Collections.reverseOrder verwenden, um den minimalen Heap umzukehren. Die Prioritätswarteschlange repräsentiert direkt einen Min-Heap in Java.
Wir haben den Max Heap mithilfe einer Prioritätswarteschlange im folgenden Programm implementiert.
import java.util.*; class Main { public static void main(String args()) { // Create empty priority queue //with Collections.reverseOrder to represent max heap PriorityQueue pQueue_heap = new PriorityQueue(Collections.reverseOrder()); // Add items to the pQueue using add() pQueue_heap.add(10); pQueue_heap.add(90); pQueue_heap.add(20); pQueue_heap.add(40); // Printing all elements of max heap System.out.println('The max heap represented as PriorityQueue:'); Iterator iter = pQueue_heap.iterator(); while (iter.hasNext()) System.out.print(iter.next() + ' '); // Print the highest priority element (root of max heap) System.out.println('
Head value (root node of max heap):' + pQueue_heap.peek()); // remove head (root node of max heap) with poll method pQueue_heap.poll(); //print the max heap again System.out.println('
Max heap after removing root: '); Iterator iter2 = pQueue_heap.iterator(); while (iter2.hasNext()) System.out.print(iter2.next() + ' '); } } Ausgabe:
Heap-Sortierung in Java
Die Heap-Sortierung ist eine Vergleichssortiertechnik ähnlich der Auswahlsortierung, bei der für jede Iteration ein maximales Element im Array ausgewählt wird. Die Heap-Sortierung verwendet die Heap-Datenstruktur und sortiert die Elemente, indem aus den zu sortierenden Array-Elementen ein Min- oder Max-Heap erstellt wird.
Wir haben bereits diskutiert, dass der Wurzelknoten im Min- und Max-Heap das minimale bzw. maximale Element des Arrays enthält. Bei der Heap-Sortierung wird das Stammelement des Heaps (min oder max) entfernt und in das sortierte Array verschoben. Der verbleibende Heap wird dann Heapifiziert, um die Heap-Eigenschaft beizubehalten.
Wir müssen also zwei Schritte rekursiv ausführen, um das angegebene Array mithilfe der Heap-Sortierung zu sortieren.
- Erstellen Sie einen Heap aus dem angegebenen Array.
- Entfernen Sie das Stammelement wiederholt aus dem Heap und verschieben Sie es in das sortierte Array. Heapifizieren Sie den verbleibenden Heap.
Die zeitliche Komplexität der Heap-Sortierung beträgt in allen Fällen O (n log n). Die Raumkomplexität ist O (1).
Heap-Sortieralgorithmus In Java
Im Folgenden sind die Heap-Sortieralgorithmen angegeben, mit denen das angegebene Array in aufsteigender und absteigender Reihenfolge sortiert werden kann.
# 1) Heap-Sortieralgorithmus zum Sortieren in aufsteigender Reihenfolge:
- Erstellen Sie einen maximalen Heap für das zu sortierende Array.
- Löschen Sie den Stamm (Maximalwert im Eingabearray) und verschieben Sie ihn in das sortierte Array. Platzieren Sie das letzte Element im Array im Stammverzeichnis.
- Heapifizieren Sie die neue Wurzel des Heaps.
- Wiederholen Sie die Schritte 1 und 2, bis das gesamte Array sortiert ist.
# 2) Heap-Sortieralgorithmus zum Sortieren in absteigender Reihenfolge:
- Erstellen Sie einen minimalen Heap für das angegebene Array.
- Entfernen Sie den Stamm (Mindestwert im Array) und tauschen Sie ihn mit dem letzten Element im Array aus.
- Heapifizieren Sie die neue Wurzel des Heaps.
- Wiederholen Sie die Schritte 1 und 2, bis das gesamte Array sortiert ist.
Implementierung der Heap-Sortierung in Java
Das folgende Java-Programm verwendet die Heap-Sortierung, um ein Array in aufsteigender Reihenfolge zu sortieren. Dazu konstruieren wir zuerst einen Max-Heap und tauschen dann rekursiv das Root-Element aus und Heapifizieren, wie im obigen Algorithmus angegeben.
import java.util.*; class HeapSort{ public void heap_sort(int heap_Array()) { int heap_len = heap_Array.length; // construct max heap for (int i = heap_len / 2 - 1; i >= 0; i--) { heapify(heap_Array, heap_len, i); } // Heap sort for (int i = heap_len - 1; i >= 0; i--) { int temp = heap_Array(0); heap_Array(0) = heap_Array(i); heap_Array(i) = temp; // Heapify root element heapify(heap_Array, i, 0); } } void heapify(int heap_Array(), int n, int i) { // find largest value int largest = i; int left = 2 * i + 1; int right = 2 * i + 2; if (left heap_Array(largest)) largest = left; if (right heap_Array(largest)) largest = right; // recursively heapify and swap if root is not the largest if (largest != i) { int swap = heap_Array(i); heap_Array(i) = heap_Array(largest); heap_Array(largest) = swap; heapify(heap_Array, n, largest); } } } class Main{ public static void main(String args()) { //define input array and print it int heap_Array() = {6,2,9,4,10,15,1,13}; System.out.println('Input Array:' + Arrays.toString(heap_Array)); //call HeapSort method for given array HeapSort hs = new HeapSort(); hs.heap_sort(heap_Array); //print the sorted array System.out.println('Sorted Array:' + Arrays.toString(heap_Array)); } } Ausgabe:
Die Gesamtzeitkomplexität der Heap-Sortiertechnik beträgt O (nlogn). Die zeitliche Komplexität der Heapify-Technik beträgt O (logn). Während die zeitliche Komplexität beim Erstellen des Heaps O (n) beträgt.
Stapel gegen Heap in Java
Lassen Sie uns nun einige der Unterschiede zwischen einer Stack-Datenstruktur und einem Heap tabellarisch darstellen.
Stapel Haufen Ein Stapel ist eine lineare Datenstruktur. Ein Heap ist eine hierarchische Datenstruktur. Befolgen Sie die Bestellung von LIFO (Last In, First Out). Die Durchquerung erfolgt in der Reihenfolge der Ebenen. Wird hauptsächlich für die statische Speicherzuweisung verwendet. Wird für die dynamische Speicherzuweisung verwendet. Der Speicher wird zusammenhängend zugewiesen. Der Speicher wird an zufälligen Orten zugewiesen. Die Stapelgröße ist je nach Betriebssystem begrenzt. Keine Beschränkung der vom Betriebssystem erzwungenen Heap-Größe. Der Stapel hat nur Zugriff auf lokale Variablen. Dem Heap sind globale Variablen zugeordnet. Die Zuweisung / Freigabe des Speichers erfolgt automatisch. Die Zuweisung / Freigabe muss vom Programmierer manuell vorgenommen werden. Der Stack kann mithilfe von Arrays, Linked List, ArrayList usw. oder anderen linearen Datenstrukturen implementiert werden. Heap wird mithilfe von Arrays oder Bäumen implementiert. Wartungskosten wenn weniger. Die Wartung ist teurer. Kann zu Speichermangel führen, da der Speicher begrenzt ist. Kein Speichermangel, kann aber unter Speicherfragmentierung leiden.
Häufig gestellte Fragen
F # 1) Ist der Stapel schneller als der Heap?
Antworten: Ein Stapel ist schneller als ein Heap, da der Zugriff im Stapel im Vergleich zum Heap linear ist.
F # 2) Wofür wird ein Heap verwendet?
Antworten: Heap wird hauptsächlich in Algorithmen verwendet, die den minimalen oder kürzesten Pfad zwischen zwei Punkten finden, wie z. B. dem Dijkstra-Algorithmus, um mithilfe der Heap-Sortierung zu sortieren, für Implementierungen von Prioritätswarteschlangen (Min-Heap) usw.
F # 3) Was ist ein Haufen? Was sind ihre Typen?
Antworten: Ein Heap ist eine hierarchische, baumbasierte Datenstruktur. Ein Heap ist ein vollständiger Binärbaum. Es gibt zwei Arten von Heaps, d. H. Max. Heap, bei denen der Wurzelknoten der größte unter allen Knoten ist. Min Heap, in dem der Wurzelknoten der kleinste oder kleinste unter allen Schlüsseln ist.
F # 4) Was sind die Vorteile von Heap gegenüber einem Stapel?
Antworten: Der Hauptvorteil des Heaps gegenüber dem Stapel liegt im Heap, der Speicher wird dynamisch zugewiesen und daher gibt es keine Begrenzung für die Verwendung von Speicher. Zweitens können nur lokale Variablen auf dem Stapel zugewiesen werden, während wir auch globale Variablen auf dem Heap zuweisen können.
F # 5) Kann Heap Duplikate haben?
Antworten: Ja, es gibt keine Einschränkungen für Knoten mit doppelten Schlüsseln im Heap, da der Heap ein vollständiger Binärbaum ist und die Eigenschaften des binären Suchbaums nicht erfüllt.
Fazit
In diesem Tutorial haben wir die Heap-Typen und die Heap-Sortierung mithilfe von Heap-Typen erläutert. Wir haben auch die detaillierte Implementierung seiner Typen in Java gesehen.
=> Lesen Sie hier den perfekten Java-Schulungsleitfaden.
Literatur-Empfehlungen
- Java Graph Tutorial - Implementieren der Graphdatenstruktur
- Einführung in Datenstrukturen in C ++
- Heap-Sortierung in C ++ mit Beispielen
- AVL-Baum- und Heap-Datenstruktur in C ++
- Datenstruktur des Binärbaums in C ++
- Warteschlangendatenstruktur in C ++ mit Illustration
- Datenstruktur für zirkuläre verknüpfte Listen in C ++ mit Abbildung
- Java-Grundlagen: Java-Syntax, Java-Klasse und Java-Kernkonzepte
