Penyortiran Heap mengacu pada algoritma penyortiran yang dirancang menggunakan struktur data heap. Penumpukan adalah struktur yang kira -kira benar -benar pohon biner dan memenuhi sifat penumpukan: yaitu, nilai kunci atau indeks simpul anak selalu lebih kecil dari (atau lebih besar dari) simpul induknya.
Kompleksitas waktu rata -rata dari heap sort adalah (nlogn).
Langkah Algoritma:
1. Buat tumpukan h [0..n-1]
2. Tukar tumpukan kepala (maksimum) dan ekor tumpukan
3. Kurangi ukuran tumpukan dengan 1 dan hubungi shift_down (0). Tujuannya adalah untuk menyesuaikan data teratas dari array baru ke posisi yang sesuai.
4. Ulangi Langkah 2 sampai ukuran tumpukan adalah 1
tumpukan:
Tumpukan sebenarnya adalah pohon yang sepenuhnya biner, dan setiap simpul non-daun dari simpul non-daunnya memenuhi propertinya: kunci [i] <= key [2i+1] && kunci [i] <= kunci [2i+2] atau kunci [i]> = Kunci NOB. Tumpukan dibagi menjadi tumpukan atas yang besar dan tumpukan atas kecil. Kunci yang memuaskan [i]> = key [2i+1] && Key> = Key [2i+2] disebut tumpukan atas yang besar. Kunci yang memuaskan [i] <= key [2i+1] && Key [i] <= key [2i+2] disebut tumpukan atas kecil. Dari properti di atas, kita dapat melihat bahwa kata kunci di bagian atas tumpukan atas yang besar jelas merupakan yang terbesar dari semua kata kunci, dan kata kunci di bagian atas tumpukan atas kecil adalah yang terkecil dari semua kata kunci.
Tumpukan Ide Penyortiran:
Fitur kata kunci terbesar (kata kunci minimum) yang direkam di bagian atas tumpukan besar (tumpukan atas kecil) membuatnya mudah untuk memilih catatan terbesar (catatan minimum) dari gangguan setiap kali. Ide dasarnya adalah (tumpukan besar atas): 1) Bangun urutan awal kata kunci yang akan diurutkan (r1, r2… .rn) menjadi tumpukan atas yang besar, yang merupakan area gangguan awal; 2) bertukar elemen teratas heap r [1] dengan elemen terakhir r [n], dan kemudian dapatkan area yang tidak teratur baru (R1, R2, ... RN-1) dan wilayah yang dipesan baru (RN) dan memenuhi R [1,2 ... n-1] <= r [n]; 3) Karena tumpukan teratas baru R [1] setelah pertukaran dapat melanggar sifat-sifat tumpukan, perlu untuk menyesuaikan area yang tidak teratur saat ini (R1, R2, ... RN-1) ke heap baru, dan kemudian bertukar R [1] dengan elemen terakhir dari daerah yang tidak teratur untuk mendapatkan wilayah yang tidak teratur (R1, R2… .RN-2) dan A New Ordered untuk mendapatkan wilayah RN yang baru) (R1, R2… .RN-2) dan A New Ordered untuk mendapatkan wilayah RN) yang baru (R1, R2… .RN-2) dan A New Ordered untuk mendapatkan wilayah yang baru) (R1, R2… .RN-2) dan A New Ordered untuk mendapatkan wilayah RN) yang baru (R1, R2… .RN-2) dan A New Ordered untuk mendapatkan wilayah RN) yang baru (R1, R2… .RN-2) dan A New Ordered untuk mendapatkan wilayah RN yang baru) (R1, R2… .RN-2) dan A New Loor Ulangi proses ini sampai jumlah elemen di area yang dipesan adalah N-1, dan seluruh proses penyortiran selesai. Proses operasi adalah sebagai berikut: 1) menginisialisasi tumpukan: konstruk r [1..n] sebagai tumpukan; 2) Pertukaran elemen heap teratas R [1] dari area yang tidak tertib saat ini dengan catatan terakhir dalam interval, dan kemudian sesuaikan area baru yang tidak tertib ke tumpukan baru. Oleh karena itu, untuk penyortiran tumpukan, dua operasi yang paling penting adalah membangun tumpukan awal dan menyesuaikan tumpukan. Faktanya, membangun tumpukan awal sebenarnya adalah proses menyesuaikan tumpukan, tetapi membangun tumpukan awal adalah menyesuaikan semua node yang tidak ada daun.
Contoh ilustrasi
Diberikan array pembentuk a [] = {16,7,3,20,17,8}, heap sortinya. Pertama, bangun pohon biner lengkap berdasarkan elemen array, dan dapatkan
Kemudian Anda perlu membangun tumpukan awal, dan kemudian mulai penyesuaian dari simpul non-daun terakhir. Proses penyesuaian adalah sebagai berikut:
Setelah pertukaran 20 dan 16, 16 penyebab 16 tidak memenuhi sifat -sifat tumpukan, sehingga perlu disesuaikan kembali.
Ini memberikan tumpukan awal.
Ketika disesuaikan terlebih dahulu, itu menjadi tumpukan besar.
Artinya, setiap penyesuaian adalah untuk memilih yang terbesar dari simpul induk, simpul anak kiri, dan simpul anak yang tepat untuk bertukar dengan simpul induk (setelah pertukaran, simpul anak yang dipertukarkan dapat menyebabkan simpul anak dipertukarkan lagi setelah setiap pertukaran). Dengan tumpukan awal, Anda dapat mengurutkannya.
Pada saat ini, 3 terletak di bagian atas tumpukan dan sifat -sifatnya tidak penuh dengan tumpukan. Anda perlu menyesuaikan dan terus menyesuaikan.
Dengan cara ini, seluruh interval sudah tertib. Dari proses di atas, kita dapat melihat bahwa penyortiran tumpukan sebenarnya adalah semacam penyortiran pilihan, penyortiran pilihan pohon. Tetapi untuk secara langsung memilih pesanan, untuk memilih catatan maksimum dari R [1 ... n], N-1 kali perlu dibandingkan, dan kemudian memilih catatan maksimum dari R [1 ... n-2], n-2 kali perlu dibandingkan. Faktanya, banyak dari perbandingan N-2 ini telah dilakukan dalam perbandingan N-1 sebelumnya, dan penyortiran pemilihan pohon hanya menggunakan karakteristik pohon untuk menyimpan beberapa hasil perbandingan sebelumnya, sehingga jumlah perbandingan dapat dikurangi. Untuk urutan kata kunci N, paling buruk, setiap node perlu membandingkan waktu log2 (n), sehingga kompleksitas waktu terburuknya adalah nlogn. Heap Sorts tidak stabil dan tidak cocok untuk disortir dengan lebih sedikit catatan. Begitu banyak yang telah dijelaskan di atas. Singkatnya, praktik dasar penyortiran heap adalah: pertama, gunakan data asli untuk membangun tumpukan besar (kecil) sebagai area asli yang tidak tertib, dan kemudian, setiap kali elemen heap teratas dikeluarkan dan ditempatkan di area yang dipesan. Karena elemen atas tumpukan diambil, kami meletakkan elemen terakhir di tumpukan ke bagian atas tumpukan, sehingga sifat -sifat tumpukan dihancurkan. Kita perlu menyesuaikan kembali tumpukan dan melanjutkan n kali, maka elemen N di area yang tidak tertib dimasukkan ke dalam area yang dipesan, dan proses penyortiran selesai.
(Tumpukan bangunan berasal dari bawah ke atas)
Aplikasi Praktis:
Dalam praktiknya, kami melakukan penyortiran tumpukan untuk mendapatkan nilai maksimum atau minimum dalam kondisi tertentu. Misalnya: 10 nilai maksimum perlu ditemukan di antara 100 angka. Oleh karena itu, kami mendefinisikan tumpukan ukuran 10, membangun sepuluh data pertama dalam 100 menjadi tumpukan atas kecil (bagian atas tumpukan), dan kemudian membandingkannya dengan bagian atas tumpukan dari data ke -11 dalam 100 data. Jika bagian atas tumpukan lebih kecil dari data saat ini, bagian atas tumpukan muncul, tekan data saat ini ke bagian atas tumpukan, dan kemudian pindahkan data dari bagian atas tumpukan ke posisi tertentu.
Kode:
tes kelas publik {static int [] arr; // heap array, valid array test publik0 (int m) {arr = new int [m];} static int m = 0; ukuran int statis = 0; // digunakan untuk menandai data yang valid dalam heap public void addToSmall (int v) {// int [] a = a = heap public void addToSmall (int v) {// int [] a = a = {16,4,5,9,1,10,11,12,13,14,15,2,3,6,7,8,111,222,333,555,66,67,54}; // Ukuran Tumpukan adalah 10 // ARR = baru int [10]; if (size <arr.length) {arr [size] = v; add_sort (size); // add_sort1 (ukuran); ukuran ++;} else {arr [0] = v; add_sort1 (0);}} public void printsmall () {for (int i = 0; i <size;} {iPricsmall () {for (int i = 0; i <ukuran; i ++ ++ {iN. {) {for (int i = 0; i <i size; i++{iNPID (for. void del () {size-; arr [0] = arr [9]; add_sort1 (0);} public void kecil (indeks int) {if (m <arr.length) {add_sort (index); m ++;} else {add_sort1 (index); m ++; Koordinat: indeks *Node anak kiri: indeks *2 *Node anak kanan: indeks *2+1 *Jika yang terakhir dalam array aneh, itu adalah anak kiri *jika yang terakhir dalam array bahkan, itu adalah anak yang tepat jika simpul anak lebih besar dari simpul induk, pertukaran nilai dilakukan. If the right child is larger than the left child, value exchange is performed* */int par;if(index!=0){if(index%2==0){par=(index-1)/2;if(arr[index]<arr[par]){swap(arr,index,par);add_sort(par);}if(arr[index]>arr[par*2]){swap(arr,index,par*2);if(arr[in dex] <arr [par]) {swap (arr, index, par);} add_sort (par);}} else {par = index/2; if (arr [index] <arr [par]) {swap (arr, index, par); add_sort (par);} if (arr [index] <arr [par*2+]; par*2+1);if(arr[index]<arr[par]){swap(arr,index,par);}add_sort(par);}}}} public void add_sort1(int index){//Adjust small top heap/*Adjust top down* As long as the child node is larger than the parent node's value, value exchange is performed, */int left=index*2;int right=index*2+1;int max = 0; if (kiri <10 && arr [kiri] <arr [index]) {max = left;} else {max = index;} if (kanan <10 && arr [kanan] <arr [max]) {max = kanan;} if (max! = index) {swap (arr, max, index); add_sort1 (max); Impor java.util.scanner; kelas publik Main_test0 {public static void main (string args []) {scanner scan = pemindai baru (System.in); System.out.println ("(Test Test) Small Test = uji heap:"); int m = scan.nextint (); uji top) test = uji heap: "); int m = scan.nextint (); test test = uji = uji heap:"); int m = scan.nextint (); uji baru) test = test = ") (int m = scan.nextint (); uji baru) test = uji heap:"); int m = scan.nextint (); uji baru) test = {16,4,5,9,1,10,11,12,13,14,15,2,3,6,7,8}; untuk (int i = 0; i <a.length; i ++) {test.addtoSmall (a [i]);} test.printsmall (); test.del (); uji (i]);} test.printsmall (); test.del (); uji.) (););); scyose ();); scrintslose (); uji (); uji (); uji (); uji (); uji (); uji (); uji (); uji (); uji.);Contoh penyortiran java heap di atas (tumpukan atas besar, tumpukan atas kecil) 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.