Tumpukan Penyortiran: Menggunakan tumpukan akar besar
Semua array dimasukkan ke dalam tumpukan, kemudian tumpukan dilepaskan dari tumpukan dan dimasukkan kembali ke array dari belakang ke depan, dan array dipesan dari kecil ke besar.
Kelas Publik MaxHeap <T memperluas yang sebanding <? super t >> {private t [] data; ukuran int pribadi; kapasitas int pribadi; public maxHeap (int kapasitas) {this.data = (t []) baru sebanding [kapasitas + 1]; ukuran = 0; this.capacity = kapasitas; } public int size () {return this.size; } public boolean isEmpty () {return size == 0; } public int getCapacity () {return this.capacity; } / ** * @return Lihat root maksimum (hanya melihatnya tanpa penghapusan, dibandingkan dengan POPMAX) * / public t seekMax () {return data [1]; } swap public void (int i, int j) {if (i! = j) {t temp = data [i]; data [i] = data [j]; data [j] = temp; }} public void insert (t item) {size ++; data [ukuran] = item; shiftup (ukuran); } / ** * @return pop root maksimum (popup berarti penghapusan, dibandingkan dengan seekMax) * / public t popmax () {swap (1, size--); shiftdown (1); Mengembalikan data [ukuran + 1]; } / ** * @param Child Tanda sudut bawah simpul anak adalah anak, dan tabel sudut bawah node induk adalah anak / 2 * / public void shiftup (int child) {while (anak> 1 && data [anak] .compareto (data [anak / 2])> 0) {sapu (anak, anak / 2); anak = anak / 2; }}/*** @param Tanda sudut bawah elemen dalam array data* @param b tanda sudut bawah elemen dalam array data* @return Tanda sudut bawah dari elemen mana yang besar*/private int max (int a, int b) {if (a] return b (b] {b) 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); terbesar = maks (terbesar, c); kembali lebih besar; }/** * @param Ayah Tanda sudut bawah simpul induk adalah ayah, dan tabel sudut bawah dari dua node anak kiri dan kanan adalah: ayah * 2 dan ayah * 2 + 1 */public void shiftdown (int ayah) {while (true) {int lChild = ayah * 2; // anak kiri int rchild = 2 2 + 1;//father. Siapakah tanda sudut bawah induk, node kiri dan kanan? If (lChild> size) {// Jika Node Ayah tidak memiliki anak atau anak kanan kembali; } lain jika (rchild> size) {// jika node ayah hanya memiliki anak, tidak ada anak yang tepat newfather = max (ayah, lchild); } else {// Jika node ayah memiliki anak kiri maupun anak baru newfather = max (ayah, lchild, rchild); } if (newFather == ayah) {// Ini berarti ayah lebih besar dari kedua node anak, dan nama tabel sudah merupakan tumpukan akar yang besar, jadi tidak perlu terus menyesuaikan pengembalian; } else {// Sebaliknya, Anda perlu terus menyesuaikan tumpukan sampai kondisi heap root besar dipenuhi swap (ayah, newfather); // value exchange father = newFather; // perbarui nilai ayah, yang setara dengan terus menyesuaikan shiftdown (newFather)}}} static public static <t t extends <? super t >> void sort (t [] arr) {int len = arr.length; // in-heap maxheap <t> maxheap = new maxheap <t> (len); untuk (int i = 0; i <len; i ++) {maxheap.insert (arr [i]); } // out-heap untuk (int i = len-1; i> = 0; i--) {arr [i] = maxheap.popmax (); }} public static void printarR (objek [] arr) {for (objek 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 sort (arr); printarr (arr); // 0 1 2 3 4 5 6 7 8 9}}Heap Sorting: Bangun tumpukan pada array (tumpukan maksimum)
Kelas Publik MaxHeap <T memperluas yang sebanding <? super t >> {private t [] data; ukuran int pribadi; kapasitas int pribadi; public maxHeap (int kapasitas) {this.capacity = kapasitas; this.size = 0; this.data = (t []) baru sebanding [kapasitas + 1]; } public maxheap (t [] arr) {// heapify, array heap capasity = arr.length; data = (t []) baru sebanding [kapasitas + 1]; System.ArrayCopy (ARR, 0, Data, 1, arr.length); size = arr.length; untuk (int i = ukuran / 2; i> = 1; i--) {shiftown (i); }} public int size () {return this.size; } public int getCapacity () {return this.capacity; } public boolean isEmpty () {return size == 0; } public T seekMax () {return data [1]; } swap public void (int i, int j) {if (i! = j) {t temp = data [i]; data [i] = data [j]; data [j] = temp; }} public void insert (t item) {size ++; data [ukuran] = item; shiftup (ukuran); } public t popmax () {swap (1, size--); shiftdown (1); Mengembalikan data [ukuran + 1]; } public void shiftup (int child) {while (anak> 1 && data [anak] .compareto (data [anak / 2])> 0) {swap (anak, anak / 2); anak /= 2; }}/*** @param Tanda sudut bawah elemen dalam array data* @param b tanda sudut bawah elemen dalam array data* @return return elemen mana yang lebih besar, tanda sudut bawah dari elemen mana yang lebih besar*/int private int max (int a, int b) {if (a] .compareto (data [b] <0) {if {if (a]. 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); terbesar = maks (terbesar, c); kembali terbesar; } public void shiftDown (int ayah) {while (true) {int lChild = ayah * 2; int rchild = ayah * 2 + 1; int newfather = ayah; // tidak masalah apakah penugasan ditetapkan di sini. Jika pengembalian berikut diubah menjadi pecah, itu harus ditetapkan jika (ukuran lchild>) {// Jika tidak ada anak kiri dan kanan kembali; } lain jika (rchild> size) {// jika tidak ada anak yang benar newFather = max (ayah, lchild); } else {// Jika ada anak -anak kiri dan kanan newFather = max (ayah, lchild, rchild); } if (newFather == ayah) {// Jika simpul induk asli adalah yang terbesar dari tiga, Anda tidak perlu terus memilah tiang punggung; } else {// simpul induk bukan yang terbesar, bertukar anak yang lebih tua dan terus menyesuaikan ke bawah sampai tumpukan akar yang besar dipenuhi pertukaran (NewFather, ayah); ayah = newfather; // setara dengan shiftdown (newfather). Jika Newfather ternyata adalah anak kiri ayah, itu setara dengan shiftdown (2*ayah)}}} public static <t meluas sebanding <? super t >> void sort (t [] arr) {int len = arr.length; Maxheap <t> maxheap = maxheap baru <> (arr); untuk (int i = len-1; i> = 0; i--) {arr [i] = maxheap.popmax (); }} public static void printarR (objek [] arr) {for (objek 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 sort (arr); printarr (arr); // 0 1 2 3 4 5 6 7 8 9}}Contoh penyortiran tumpukan di atas (implementasi array java) adalah semua konten yang saya bagikan dengan Anda. Saya harap Anda dapat memberi Anda referensi dan saya harap Anda dapat mendukung wulin.com lebih lanjut.