Heapsortierung: Verwenden Sie große Wurzelhaufen
Alle Arrays werden in den Haufen eingegeben, der Haufen wird vom Haufen freigesetzt und von hinten nach vorne zurück in das Array eingeführt, und das Array wird von klein bis groß bestellt.
öffentliche Klasse Maxheap <T erweitert vergleichbar <? Super t >> {private t [] Daten; private intgröße; private intkapazität; public maxheap (intkapazität) {this.data = (t []) Neu vergleichbar [Kapazität + 1]; Größe = 0; this.capacity = Kapazität; } public int size () {return this.size; } public boolean isempty () {return size == 0; } public int getCapacity () {return this.capacity; } / ** * @return anzeigen Sie das maximale Root (nur sehen Sie es ohne Löschen im Vergleich zu Popmax) * / public t seexax () {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); } / ** * @return pop Das maximale Root (Popup bedeutet Löschung im Vergleich zu seeex) * / public t popmax () {Swap (1, Größe-); Verschiebung (1); Daten zurückgeben [Größe + 1]; } / ** * @Param Child Die untere Eckmarke des untergeordneten Knotens ist ein Kind, und die untere Ecktabelle des übergeordneten Knotens ist ein Kind / 2 * / public void Shiftup (int mind) {while (Child> 1 && Daten [Kind] .Compareto (Daten [Kind / 2])> 0) {Swap (Child, Child / 2); Kind = Kind / 2; }}/*** @param Eine untere Eckmarke eines Elements im Datenarray* @param b Die untere Eckmarke eines Elements im Datenarray* @return Das untere Eckmarke ist groß*/privat int max (int a, int b) {if (Daten [a] .Compareto (Daten [b]) {// if Data [b; 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 lower corner mark of an element in the data array* @return The lower corner mark of an element in the data array*/ private int max(int a, int b, int c) { int biggest = max(a, b); größtes = max (größte, c); kehre größer zurück; }/** * @param father Die untere Ecke des übergeordneten Knotens ist Vater, und die unteren Ecktabellen der linken und rechten zwei Kinderknoten sind: Vater * 2 und Vater * 2 + 1 */public void Shiftdown (int Vater) {während (wahr) {int lchild = vater * 2; // links kind in inthild = vather * 2 + 1. Wer ist die untere Ecke des übergeordneten, linken und rechten Knotens? If (lchild> Größe) {// Wenn der Vaterknoten weder ein Kind noch das rechte Kind zurückkehrt; } else if (rchild> size) {// Wenn der Vaterknoten nur ein Kind verletzt hat, kein rechter Kinderregel = max (Vater, LChild); } else {// Wenn der Vaterknoten sowohl ein neues Kind als auch das rechte Kinder -Neuheit = max (Vater, Lchild, rchild) hat; } if (newfather == father) {// Es bedeutet, dass Vater größer ist als beide Kinderknoten, und der Tabellenname ist bereits ein großer Wurzelhaufen, sodass die Rückkehr nicht weiter anpassen muss. } else {// ansonsten müssen Sie den Heap weiter anpassen, bis der große Wurzelhaufen -Zustand erfüllt ist (Vater, Neuvater). super t >> void sort (t [] arr) {int len = arr.length; // in-heap maxheap <t> maxheap = neuer Maxheap <t> (Len); für (int i = 0; i <len; i ++) {maxheap.insert (arr [i]); } // out-heap for (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 static void main (String args []) {Integer [] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6}; printarr (arr); // 3 5 1 7 2 9 8 0 4 6 sortieren (arr); printarr (arr); // 0 1 2 3 4 5 6 7 8 9}}Heapsortierung: Konstruieren Sie den Haufen auf dem Array (Maximum Heap)
ö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); 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 static void main (String args []) {Integer [] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6}; printarr (arr); // 3 5 1 7 2 9 8 0 4 6 sortieren (arr); printarr (arr); // 0 1 2 3 4 5 6 7 8 9}}Das obige Heap -Sortierbeispiel (Java -Array -Implementierung) ist der gesamte Inhalt, den ich mit Ihnen teile. Ich hoffe, Sie können Ihnen eine Referenz geben und ich hoffe, Sie können wulin.com mehr unterstützen.