Ein binärer Haufen ist ein besonderer Haufen. Ein binärer Haufen ist ein vollständiger binärer Baum (binärer Baum) oder ein ungefähr vollständiger binärer Baum (binärer Baum). Es gibt zwei Arten von binären Haufen: den größten Haufen und den kleinsten Haufen. Maximaler Heap: Der Schlüsselwert des übergeordneten Knotens ist immer größer oder gleich dem Schlüsselwert eines untergeordneten Knotens. Mindesthaufen: Der Schlüsselwert des übergeordneten Knotens ist immer geringer als oder gleich dem Schlüsselwert eines Kinderknotens.
Drucken Binärhaufen: Verwenden Sie hierarchische Beziehungen
Hier sortiere ich zuerst den Haufen und führe dann die Methode aus, um den Haufen in sortierter printAsTree() zu drucken
öffentliche Klasse Maxheap <T erweitert vergleichbar <? Super t >> {private t [] Daten; private intgröße; private intkapazität; public maxheap (intkapazität) {this.capacity = Kapazität; this.size = 0; this.data = (t []) Neu vergleichbar [Kapazität + 1]; } public maxheap (t [] arr) {// Heapify, Array Heap Capaction = arr.length; Daten = (t []) Neu vergleichbar [Kapazität + 1]; System.ArrayCopy (arr, 0, Daten, 1, arr.Length); size = arr.length; für (int i = size / 2; i> = 1; i--) {Verschiebung (i); }} public int size () {return this.size; } public int getCapacity () {return this.capacity; } public boolean isempty () {return size == 0; } public t seeexmax () {returndaten [1]; } public void swap (int i, int j) {if (i! = j) {t temp = data [i]; Daten [i] = Daten [j]; Daten [j] = temp; }} public void Insert (t item) {size ++; Daten [Größe] = Artikel; Verschiebung (Größe); } public t popmax () {Swap (1, Größe--); Verschiebung (1); Daten zurückgeben [Größe + 1]; } public void ShiftUp (int Child) {while (Child> 1 && Daten [Kind] .Compareto (Daten [Kind / 2])> 0) {SWAP (Child, Child / 2); Kind /= 2; }}/*** @param Eine untere Eckmarke eines Elements im Datenarray* @param b untere Ecke eines Elements im Datenarray* @Return Return Welches Element ist größer, der untere Eckmarke ist größer*/privat int max (int a, int b) {if (data [a] .Compareto (data [b] <0). data[a] big return a;//Return a } } /** * @param a lower corner mark of an element in the data array* @param b lower corner mark of an element in the data array* @param c The lower corner mark of an element in the data array* @return The lower corner mark of which element is larger*/ private int max(int a, int b, int c) { int biggest = max(a, b); größtes = max (größte, c); am größten zurückkehren; } public void Shiftdown (int Vater) {while (true) {int lchild = father * 2; int rchild = Vater * 2 + 1; int newather = father; // Es spielt keine Rolle, ob die Aufgabe hier zugewiesen wird. Wenn die folgende Rückgabe in Break geändert wird, muss er zugewiesen werden, wenn (lchild> Größe) {// Wenn keine linken und rechten Kinder zurückkehren; } else if (rchild> size) {// wenn es keinen richtigen Kinderreal = max (Vater, lchild) gibt; } else {// wenn es einen linken und rechten Kinder -Neuheit = max (Vater, Lchild, rchild) gibt; } if (newfather == father) {// Wenn der ursprüngliche übergeordnete Knoten der größte von drei ist, müssen Sie die Stapelrendite nicht weiter aussortieren. } else {// Der übergeordnete Knoten ist nicht der größte, tauschen Sie die älteren Kinder aus und passen Sie die Abwärtsversuche weiter an, bis der große Wurzelhaufen zufrieden ist (Neuheit, Vater); Vater = Neuvater; // Äquivalent zur Verschiebung (Neuendlichkeit). Wenn sich herausstellt, dass der Neuvater das linke Kind des Vaters ist, entspricht dies der Verschiebung (2*Vater)}}} Public static <t erweitert vergleichbar <? super t >> void sort (t [] arr) {int len = arr.length; Maxheap <t> maxheap = neuer Maxheap <> (arr); maxheap.printastree (); für (int i = len-1; i> = 0; i--) {arr [i] = maxheap.popmax (); }} public static void printarr (Objekt [] arr) {für (Objekt O: arr) {System.out.print (o); System.out.print ("/t"); } System.out.println (); } public void printspace (int n) {// drucken n leer (verwendet stattdessen mit '/t' hier) für (int i = 0; i <n; i ++) {System.out.printf ("%3S", ""); }} public void printastree () {int linenum = 1; // Erste Überquelle der ersten Zeile int line = (int) (math.log (Größe)/math.log (2)) + 1; // Zeilen ist die Anzahl der Ebenen des Heap -Int SpaceNum = (int) (math.pow.pow (2) - 1); für (int i = 1; i <= size;) {// Da Daten im linken und rechts geschlossenen Intervall in [1 ... Größe] gespeichert sind, speichert Daten [0] keine Daten // Jede Ebene druckt dieses Intervall [2^(Schicht Nummer 1) ... (2^Schichtzahl) -1]. Wenn die Zahl im Haufen nicht ausreicht (2^ Schichten) -1, drucken Sie sie zur Größe. Nehmen Sie also min ((2^ Schichten) -1, Größe). für (int j = (int) math.pow (2, linenum - 1); j <= math.min (Größe, (int) math.pow (2, linenum) - 1); j ++) {printspace (spacenum); // Räume mit spazenum system.out.printf ("%3S", Daten [j]); // data system.out.printf ("%3s", ""); // Green Box im Bilddruckspace (Spaceum); // Räume mit Spaceum i ++ drucken; // Jedes Element wird gedruckt, es ist+1} Leinenum ++; spacenum = spacenum / 2; System.out.println (); }} public static void main (String args []) {Integer [] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6, 1, 3, 6, 1, 1}; sortieren (arr); }}Ausführungsergebnisse:
Zusammenfassen
Das obige ist der gesamte Inhalt dieses Artikels über den Druckcode -Austausch der Java -Sprache, die binäre Haufen implementiert. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!