Tumpukan maksimum
Tumpukan terbesar adalah bahwa elemen induk lebih besar dari elemen anak dan merupakan pohon yang benar -benar biner.
Data [1] mulai menyimpan, data [0] kosong dan tidak digunakan. Anda juga dapat menggunakan data [0] sebagai ukuran.
Kelas Publik MaxHeap <T memperluas yang sebanding <? super t >> {private t [] data; ukuran int pribadi; kapasitas int pribadi; maxheap publik (kapasitas int) {this.data = (t []) baru sebanding [kapasitas + 1]; size = 0; this.capacity = kapasitas;} public int size () {return this.size;} public boolean isempty () {return ukuran == 0 this.capacity;}/** * @Return Lihat root maksimum (hanya melihatnya tanpa penghapusan, dibandingkan dengan popmax) */public t seekmax () {return data [1];} public void swap (int i, int j) {if (i! = j) {t temp = data [i]; data [i] = data [j if (i! = {size ++; data [size] = item; shiftup (size);}/*** @return pop root maksimum (popup berarti penghapusan, dibandingkan dengan seekMax)*/public t popmax () {swap (1, ukuran-) pojok nol (1); noda kembalinya [ukuran+1];}/** ** @param anak NOKS Lower data [ukuran node+1];}/** ** @param anak noncoDdown The Lower Corner [Ukuran NOKS+1];}/** ** @param KICK TANDA KIDA Lower (1); NODE NOKS NOME [Ukuran+1];}/** @param KICK KICK/NOBER Lower NOLDS NOBSE [Ukuran NOKS+1];}/** @param KICK KICK DOFTDOW * / shiftup public void (int child) {while (child> 1 && data [anak] .compareto (data [anak / 2])> 0) {swap (anak, anak / 2); anak = anak / 2;}} / *** @param Markus yang lebih rendah dari elemen yang lebih rendah* @param b Mark yang lebih rendah dari sorse di sudut data yang lebih rendah* @priving corne @ a, int b) {if (data[a].compareTo(data[b]) < 0) {//If data[b] big return b;//return b} else {//If 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 lower corner mark of an element in the data Array*@return mengembalikan tanda sudut bawah dari elemen mana yang besar*/private int max (int a, int b, int c) {int terbesar = max (a, b); terbesar = maks (terbesar, c); kembali lebih besar;}/***@param Tanda sudut yang lebih rendah dari node induk*2, dan tabel sudut yang lebih rendah dari secoing anak kiri dan kanan adalah: Soal anak kanan adalah: Soal anak -anak adalah: THE TOPLED 2 adalah TAGIAN 2, dan TABUNG POULD 2 TABUNG PUBLID, DAN POBER DAN TABUNGAN PUBLID LEDER DAN TAGID 2, dan TABUNG POULDE BAGU ADALAH POULD DAN POBER DAN TABUNGAN BEBO DAN POBER DAN TABUNGAN BEBOD DAN TABUNGAN BEBO DAN POMUND LEWK (true) {int lChild = ayah * 2; // kiri anak int rchild = ayah * 2 + 1; // anak kanan int newfather = ayah; // newfather akan segera diperbarui. Siapakah tanda sudut bawah induk, node kiri dan kanan? Jika (lchild> size) {// Jika simpul ayah tidak memiliki anak kiri maupun anak yang tepat kembali;} lain jika (rchild> size) {// Jika node ayah hanya memiliki anak kiri, tidak ada anak yang tepat Newfather = Max (ayah, LCHILD);} lain {// jika node ayah memiliki kedua anak kiri dan anak kanan = detfather = DAGHILD = DAGHILD = DAGHILD, Max, Max, RATHLILD, NODE, NODE KADU NODE KIRI KIRI DAN KANAN KANAN = DAGHTHED = DAGHTHED = DAGHILD = DAGHILD = DAGHCHLILD = DAGHILD = DAGHILD = DAGHILD = DAGHILD, Max, RATHLILD, ROMEDID; father) {//It means that father is larger than both child nodes, and the table name is already a big root heap, so there is no need to continue to adjust the return;} else {// Otherwise, you need to continue to adjust the heap until the big root heap condition is met swap(father, newFather);//Values are swap = newFather;//Update the value of father, which is equivalent to continuing to adjust shiftdown (newFather)}}} public static void main (string [] args) {// Buat heap root besar maxheap <Integer> maxheap = new maxheap <Integer> (100); // save for (int i = 0; i <100; i ++) {maxheap.insert ((int) (matematika) (matematika) (i+) {maxHeap.insert ((int) (math.randan) <100; i ++) {maxHeap.insert ((int) (math.randan) (i+) {maxheap.insert ((int) (math.randand = integer baru [100]; // Pilih dari tumpukan dan masukkan ke dalam array untuk (int i = 0; i <100; i ++) {arr [i] = maxheap.popmax (); System.out.print (arr [i]+"");} system.out.println ();}}Fungsi Maximum Heap: ShiftDown () berbeda dari yang di atas
Kelas Publik MaxHeap <T memperluas yang sebanding <? super T>> {private T[] data;private int size;private int capacity;public MaxHeap(int capacity) {data = (T[]) new Comparable[capacity + 1];this.capacity = capacity;size = 0;}public int size() {return size;}public Boolean isEmpty() {return size == 0;}public void insert(T item) {data[size + 1] = item; ukuran ++; shiftup (ukuran);}/** * @return pop max root (pop-up berarti penghapusan, dibandingkan dengan seekMax) */topmax t publik () {t ret = data [1]; swap (1, ukuran); ukuran-satu-satunya tayangan (1); return;}/** @return tampilan akar maksimum (satu-satunya tampilan delm (1); retrion (}/** @return tampilan akar maksimum (satu-satunya tampilan delm (1); Return;}/** @return tampilan akar maksimum (satu-satunya tampilan delm (1); Return;}/** @return view root maximum tanpa maksimum (satu-satunya tayangan (1); retix; data[1];}public void swap(int i, int j) {if (i != j) {T temp = data[i];data[i] = data[j];data[j] = temp;}}public void shiftUp(int k) {while (k > 1 && data[k / 2].compareTo(data[k]) < 0) {swap(k, k / 2);k /= 2;}} public void shiftdown (int bapak) {while (2 * ayah <= size) {int newFather = 2 * ayah; if (newFather + 1 <= size && data [newFather + 1] .compareto (data [newFather])> 0) {// data [j] data [j + 1] yang mengambil bigtather baru yang baru mengambil bigfathere bigfather = needfathere = {// Data [j] ifery [j + 1] yang mengambil bigfather Big baru. (Data [ayah] .compareto (data [newFather])> = 0) {break;} else {swap (ayah, newfather); // nilainya dipertukarkan ayah = newFather; // newfather adalah (2*ayah) (2*ayah+1), yaitu, shiftdown (newfather);}} public static static), yaitu, shiftdown (newfather);}} public static static), yaitu string {New Father); {2*public static), Maxheap <Integer> maxheap = maxheap baru <integer> (100); // save for (int i = 0; i <100; i ++) {maxheap.insert ((int) (math.random () * 100);} // Buat array integer [] arr = integer baru [100];//pick dari heap ke dalam array [] arr = new integer [100];//pick dari heap ke heap ke array [] arr = new integer [100];//pick dari heap ke heap ke array [] arr = new integer [100];//pick dari heap ke the heaPer [] arr = new integer [100]; i ++) {arr [i] = maxheap.popmax (); system.out.print (arr [i]+"");} system.out.println ();}}Meringkaskan
Di atas adalah semua tentang contoh kode tumpukan maksimum implementasi bahasa Java, dan saya harap ini akan membantu semua orang. Teman yang tertarik dapat terus merujuk ke topik terkait lainnya di situs ini. Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya. Terima kasih teman atas dukungan Anda untuk situs ini!