A Binary (Max) Heap is a complete binary tree that maintains the Max Heap property.

Binary Heap is one possible data structure to model an efficient Priority Queue (PQ) Abstract Data Type (ADT). In a PQ, each element has a "priority" and an element with higher priority is served before an element with lower priority (ties are either simply resolved arbitrarily or broken with standard First-In First-Out (FIFO) rule as with a normal Queue). Try clicking ExtractMax() for a sample animation on extracting the max value of random Binary Heap above.

To focus the discussion scope, this visualization show a Binary Max Heap of integers where duplicates are allowed. See this for an easy conversion to Binary Min Heap. Generally, any other objects that can be compared can be stored in a Binary Max Heap, e.g., Binary Max Heap of floating points, etc.

Complete Binary Tree: Every level in the binary tree, except possibly the last/lowest level, is completely filled, and all vertices in the last level are as far left as possible.

Binary Max Heap property: The parent of each vertex - except the root - contains value greater than (or equal to — we now allow duplicates) the value of that vertex. This is an easier-to-verify definition than the following alternative definition: The value of a vertex - except the leaf/leaves - must be greater than (or equal to) the value of its one (or two) child(ren).

Priority Queue (PQ) Abstract Data Type (ADT) is similar to normal Queue ADT, but with these two major operations:

1. Enqueue(x): Put a new element (key) x into the PQ (in some order),
2. y = Dequeue(): Return an existing element y that has the highest priority (key) in the PQ and if ties, return any.

Discussion: Some PQ ADT reverts to First-In First-Out (FIFO) behavior of a normal Queue in the event there is a tie of highest priority (key) in the PQ. Does guaranteeing stability on equal highest priority (key) makes PQ ADT harder to implement?

Imagine: You are an Air Traffic Controller (ATC) working in the control tower T of an airport. You have scheduled aircraft X/Y to land in the next 3/6 minutes, respectively. Both have enough fuel for at least the next 15 minutes and both are just 2 minutes away from your airport. You observe that your airport runway is clear at the moment.

In case you do not know, aircraft can be instructed to fly in holding pattern near the airport until the designated landing time.

You have to attend the live lecture to figure out what happens next...

There will be two options presented to you and you will have to decide:

• Raise AND wave your hand if you choose option A,
• Raise your hand but do NOT wave it if you choose option B,

If none of the two options is reasonable for you, simply do nothing.

There are several potential usages of PQ ADT in real-life on top of what you have seen just now regarding ATC (only in live lecture).

Discussion: Can you mention a few other real-life situations where a PQ is needed?

Kita bisa mengimplementasikan ADT PQ ini menggunakan larik (sirkular) atau Senarai Berantai (Linked List) tetapi kita akan mendapatkan operasi Enqueue atau Dequeue yang pelan (yaitu dalam O(N)).

Diskusi: Kenapa?

Now, let's view the visualisation of a (random) Binary (Max) Heap above. You should see a complete binary tree and all vertices except the root satisfy the Max Heap property (A[parent(i)] ≥ A[i]). Duplicate integer keys may appear.

You can Toggle the Visualization Mode between the visually more intuitive complete binary tree form or the underlying compact array based implementation of a Binary (Max) Heap.

Quiz: Based on this Binary (Max) Heap property, where will the largest integer be located?

Can be anywhere
At one of the leaf
At the root

Submit

Fakta penting untuk dihafal saat ini: Jika kita memiliki Timbunan Biner dengan N elemen, tingginya tidak akan lebih tinggi dari O(log N) karena kita akan menaruhnya sebagai pohon biner komplet.

Analisa sederhana: Besarnya N dari sebuah pohon biner penuh (lebih dari sekedar komplet) dengan tinggi h adalah selalu N = 2^(h+1)-1, sehingga h = log₂(N+1)-1 ~= log₂ N.

Lihat contoh diatas dengan N = 7 = 2⁽²⁺¹⁾-1 or h = log₂(7+1)-1 = 2.

Fakta ini penting untuk analisa dari semua operasi-operasi yang berhubungan dengan Timbunan Biner.

A complete binary tree can be stored efficiently as a compact array A as there is no gap between vertices of a complete binary tree/elements of a compact array. To simplify the navigation operations below, we use 1-based array. VisuAlgo displays the index of each vertex as a red label below each vertex. Read those indices in sorted order from 1 to N, then you will see the vertices of the complete binary tree from top to down, left to right. To help you understand this, Toggle the Visualization Mode several times.

This way, we can implement basic binary tree traversal operations with simple index manipulations (with help of bit shift manipulation):

1. parent(i) = i>>1, index i divided by 2 (integer division),
2. left(i) = i<<1, index i multiplied by 2,
3. right(i) = (i<<1)+1, index i multiplied by 2 and added by 1.

Pro tip: Try opening two copies of VisuAlgo on two browser windows. Try to visualize the same Binary Max Heap in two different modes and compare them.

In this visualization, you can perform several Binary (Max) Heap operations:

1. Create(A) - O(N log N) version (N calls of Insert(v) below)
2. Create(A) - O(N) version
3. Insert(v) in O(log N) — you are allowed to insert duplicates
4. 3 versions of ExtractMax():
   1. Once, in O(log N)
   2. K times, i.e., PartialSort(), in O(K log N), or
   3. N times, i.e., HeapSort(), in O(N log N)
5. UpdateKey(i, newv) in O(log N if i is known)
6. Delete(i) in O(log N if i is known)

There are a few other possible Binary (Max) Heap operations, but currently we do not elaborate them for pedagogical reason in a certain NUS module.

Masukkan(v): Memasukkan nilai baru v ke dalam Timbunan Biner Maks hanya dapat dilakukan pada indeks terakhir N plus 1 untuk mempertahankan properti larik padat = pohon biner komplet. Namun, properti Timbunan Maks masih dapat dilanggar. Operasi ini kemudian membetulkan properti tersebut dari titik masukkan ke atas (jika perlu) dan berhenti ketika properti tersebut tidak dilanggar lagi. Sekarang cobalah klik Insert(v) beberapa kali untuk memasukkan beberapa nilai v acak ke Timbunan Biner (Maks) yang ditunjukkan saat ini.

Apakah anda mengerti kenapa memulai dari tempat pemasukan (indeks N+1) keatas (sampai maksimum simpul akar) dan menukar sebuah simpul dangan orang tuanya ketika terjadi pelanggaran properti Timbunan Maks selama pemasukkan adalah sebuah strategi yang benar?

Kompleksitas waktu dari operasi Masukkan(v) ini adalah O(log N).

Diskusi: Apakah anda mengerti penurunannya?

EkstrakMaks(): Pelaporan dan penghapusan nilai maksimum (akar) dari Timbunan Biner Maks memerlukan sebuah elemen lain untuk menggantikannya, karena jika tidak, maka Timbunan Biner Maks (sebuah pohon biner komplit, atau 林/Lín dalam bahasa Mandarin/pohon) menjadi dua sub-pohon yang terpisah (dua kopi dari 木/mù dalam bahasa Mandarin/kayu). Elemen tersebut harus merupakan indeks terakhir N dengan alasan yang sama: Untuk menjaga properti larik padat (compact) = pohon biner komplet.

Karena kita mempromosikan sebuah simpul daun menjadi simpul akar dari sbeuah Timbunan Biner, properti Timbunan Maks dapat dilanggar dengan mudah. Operasi EkstraksMaks() ini lalu membetulkan kembali properti tersebut mulai dari akar ke bawah dengan membandingkan nilai saat ini dengan anak-anaknya/yang lebih besar (bila perlu). Sekarang cobalah ExtractMax() pada Timbunan Biner (Maks) yang ditunjukkan saat ini.

Operasi membetulkan properti Timbunan Maks kebawah tidak memiliki nama standar. Kami menyebutnya ShiftDown tetapi orang-orang lain mungkin menyebutnya sebagai operasi BubbleDown atau Heapify.

Kenapa jika sebuah simpul memiliki dua anak, kita harus mengecek (dan mungkin menukar) simpul tersebut dengan anak yang lebih besar saat membereskan properti Timbunan Maks kebawah?

Kenapa kita tidak bisa membandingkan dengan simpul kiri (atau kanan, jika ada) saja?

Kompleksitas waktu dari operasi EkstrakMaks() ini adalah O(log N).

Diskusi: Apakah anda mengerti penurunannya?

Up to here, we have a data structure that can implement the two major operations of Priority Queue (PQ) ADT efficiently:

1. For Enqueue(x), we can use Insert(x) in O(log N) time, and
2. For y = Dequeue(), we can use y = ExtractMax() in O(log N) time.

However, we can do a few more operations with Binary Heap.

Buat(A): Membuat sebuah Timbunan Biner (Maks) valid dari array masukan A dengan N integer (dipisahkan dengan koma) ke dalam Timbunan Biner Maks kosong.

Ada dua varian untuk operasi ini, versi sederhana dalam O(N log N) dan versi advanced yang berjalan dalam O(N).

Pro Tip: Cobalah buka dua jendela VisuAlgo di browser anda. Jalankan kedua varian operasi Buat(A) pada kasus terburuk 'Contoh terurut' untuk melihat perbedaan mencolok dari keduanya.

Create(A) - O(N log N): Simply insert (that is, by calling Insert(v) operation) all N integers of the input array into an initially empty Binary Max Heap one by one.

Analysis: This operation is clearly O(N log N) as we call O(log N) Insert(v) operation N times. Let's examine the 'Sorted example' which is one of the hard case of this operation (Now try the Hard Case - O(N log N) where we show a case where A = [1,2,3,4,5,6,7] -- please be patient as this example will take some time to complete). If we insert values in increasing order into an initially empty Binary Max Heap, then every insertion triggers a path from the insertion point (a new leaf) upwards to the root.

Create(A) - O(N): This faster version of Create(A) operation was invented by Robert W. Floyd in 1964. It takes advantage of the fact that a compact array = complete binary tree and all leaves (i.e., half of the vertices — see the next slide) are Binary Max Heap by default. This operation then fixes Binary Max Heap property (if necessary) only from the last internal vertex back to the root.

Analysis: A loose analysis gives another O(N/2 log N) = O(N log N) complexity but it is actually just O(2*N) = O(N) — details in the next few slides. Now try the Hard Case - O(N) on the same input array A = [1,2,3,4,5,6,7] and see that on the same hard case as with the previous slide (but not the one that generates maximum number of swaps — try 'Diagonal Entry' test case by yourself), this operation is far superior than the O(N log N) version.

Pembuktian sederhana tentang mengapa separuh dari Timbunan Biner (Maks) dengan N (tanpa kehilangan makna umum, mari asumsikan bahwa N adalah genap) elemen adalah dedaunan adalah sebagai berikut:

Misalkan daun terakhir berada pada indeks N, maka orang tua dari daun terakhir tersebut ada di indeks i = N/2 (ingat slide ini). Anak kiri dari simpul i+1, jika ada (sesungguhnya tidak ada), adalah 2*(i+1) = 2*(N/2+1) = N+2, yang sudah lebih besar dari indeks N (daun terakhir) jadi indeks i+1 pasti juga adalah sebuah simpul daun yang tidak mempunyai anak. Karena indeks-indeks dari Timbunan Biner beruruta, pada dasarnya indeks-indeks [i+1 = N/2+1, i+2 = N/2+2, ..., N], yaitu separuh dari seluruh simpul-simpul, adalah dedaunan.

Pertama-tama, kita perlu mengingat bahwa tinggi dari pohon biner penuh dengan ukuran N adalah log₂ N.

Kedua, kita perlu menyadari bahwa biaya untuk menjalakan operasi shiftDown(i) tidak sejelek batas atas kasar O(log N), tetapi O(h) dimana h adalah tinggi dari sub-pohon yang berakar di indeks i.

Ketiga, ada ceil(N/2^h+1) simpul-simpul pada ketinggian h di sebuah pohon biner penuh.

Di pohon biner penuh contoh diatas dengan N = 7 dan h = 2, ada:
ceil(7/2⁰⁺¹) = 4 simpul-simpul: {44,35,26,17} pada ketinggian h = 0,
ceil(7/2¹⁺¹) = 2 simpul-simpul: {62,53} pada ketinggian h = 1, dan
ceil(7/2²⁺¹) = 1 simpul: {71} pada ketinggian h = 2.

Biaya dari Buat(A), versi O(N) adalah:

Catatan: Jika rumus ini terlalu kompleks, murid yang modern bisa menggunakan WolframAlpha.

HeapSort(): John William Joseph Williams meneukan algoritma HeapSort() pada tahun 1964, bersamaan dengan struktur data Timbunan Biner. Operasi HeapSort() (dengan asumsi bahwa Timbunan Biner Maks telah dibuat dalam O(N)) sangatlah mudah. Anda cukup memanggil operasi EkstrakMaks() yang berjalan dalam O(log N) sebanyak N kali. Sekarang cobalah HeapSort() pada Timbunan Biner (Maks) yang ditunjukkan saat ini.

Meskipun HeapSort() berjalan dalam waktu θ(N log N) untuk semua kasus (terbaik/rata-rata/terjelek), apakah Heap Sort benar-benar algoritma berbasis-pembandingan terbaik?

Diskusi: Bagaimana dengan performa caching dari HeapSort()?

We can actually just call the O(log N) ExtractMax() operation K times if we are only interested in the top K largest elements in the Binary (Max) Heap. Now try PartialSort() on the currently displayed Binary (Max) Heap. This operation is called PartialSort().

Simple Analysis: PartialSort() clearly runs in O(K log N) — an output-sensitive algorithm where the time complexity depends on the output size K.

Anda telah mencapai akhir dari bahan-bahan dasar dari struktur data Timbunan Biner (Maks) dan kami menyemangati anda untuk mengeksplorasi lebih lanjut dalam Mode Eksplorasi.

Tetapi, kami masih memiliki beberapa tantangan-tantangan menarik untuk anda tentang Timbunan Biner (Maks) yang akan kami sebutkan di bagian ini.

Ketika anda telah menyelesaikan semuanya, kami mengundang anda untuk mempelajari algoritma-algoritma yang lebih lanjut yang menggunakan Antrean Berprioritas sebagai (salah satu dari) struktur datanya, seperti algoritma MST Prim, algoritma SSSP Dijkstra, algoritma pencarian A* (belum ada di VisuAlgo), dan beberapa algoritma-algoritma berbasis-greedy lainnya, dsb.

Jika kita hanya berurusan dengan angka-angka (termasuk dalam visualisasi ini yang dibatasi nya untuk bilangan-bilangan bulat saja), maka mudah untuk mengkonversi Timbunan Biner Maks ke Timbunan Biner Min tanpa mengubah apapun, dan sebaliknya.

Kita dapat membuat ulang Timbunan Biner dengan menegasi (mengalikan dengan -1) setiap bilangan bulat di Timbunan Biner asli. Jika kita mulai dengan Timbunan Biner Maks, maka Timbunan Biner yang dihasilkan adalah Timbunan Biner Min (jika kita tidak memperdulikan simbol-simbol negatif — lihat gambar diatas), dan sebaliknya.

Untuk beberapa aplikasi-aplikasi Antrean Berprioritas (misalkan HeapDecreaseKey dalam algoritma Dijkstra), kita mungkin harus memodifikasi (menaikkan atau menurunkan) prioritas dari sebuah nilai yang sudah dimasukkan kedalam Timbunan Biner (Maks). Jika indeks i dari nilai tersebut diketahui, kita dapat menggunakan strategi mudah sebagai berikut: Mutakhirkan saja A[i] = newv dan lalu kita memanggil kedua shiftUp(i) dan shiftDown(i). Hanya maksimum satu dari operasi restorasi properti Timbunan Maks yang akan berhasil, yaitu shiftUp(i)/shiftDown(i) akan dijalankan jika newv >/< nilai lama dari A[parent(i)]/A[larger of the two children of i], masing-masing.

Sehingga, PerbaruiKunci(i, vbaru) bisa dilakukan dalam O(log N), asal saja kita mengetahui indeks i.

Untuk beberapa aplikasi-aplikasi Antrean Berprioritas, kita mungkin harus menghapus nilai yang sudah ada yang telah dimasukkan kedalam Timbunan Biner (Maks) (dan nilai ini kebetulan bukan akar). Sekali lagi, jika indeks i dari nilai tersebut diketahui, kita bisa melakukan strategi muda berikut ini: Mutakhirkan saja A[i] = A[1]+1 (sebuah angka besar yang lebih besar dari akar saat ini), panggil shiftUp(i) (secara teknis, PerbaruKunci(i, A[1]+1)). Ini akan membawa indeks i menjadi akar yang baru, dan dari situ, kita dapat dengan mudah memanggil EktraksMax() sekali untuk menghapusnya.

Maka, Hapus(i) bisa dilakukan dalam O(log N), jika kita mengetahui indeks i.

Diskusi: Sekarang untuk PerbaruiKunci(i, vbaru) dan Hapus(i), apa yang terjadi jika kita diberikan vlama dan oleh karena itu kita harus mencari lokasinya di Timbunan Biner (Maks)? Bisakah kita melakukan ini lebih cepat dari O(N)?

If you are looking for an implementation of Binary (Max) Heap to actually model a Priority Queue, then there is a good news.

C++ and Java already have built-in Priority Queue implementations that very likely use this data structure. They are C++ STL priority_queue (the default is a Max Priority Queue) and Java PriorityQueue (the default is a Min Priority Queue). However, the built-in implementation may not be suitable to do some PQ extended operations efficiently (details omitted for pedagogical reason in a certain NUS course).

Python heapq exists but its performance is rather slow. OCaml doesn't have built-in Priority Queue but we can use something else that is going to be mentioned in the other modules in VisuAlgo (the reason on why the details are omitted is the same as above).

PS: Heap Sort is likely used in C++ STL algorithm partial_sort.

---

Nevertheless, here is our implementation of BinaryHeapDemo.cpp | py | java.

Untuk beberapa pertanyaan-pertanyaan menarik tentang struktur data ini, silahkan coba latihan pada modul latihan Timbunan Biner (login tidak dibutuhkan).

Tetapi untuk murid-murid NUS, anda sebaiknya login menggunakan akun kelas resmi anda, secara ofisial menyelesaikan modul ini, dan penghargaan tersebut akan dicatat di akun pengguna anda.

Kita juga memiliki beberapa masalah-masalah pemrograman yang membutuhkan penggunaan struktur data Timbunan Biner ini: UVa 01203 - Argus dan Kattis - numbertree.

Cobalah mereka untuk mengkonsolidasikan dan meningkatkan pemahaman anda tentang struktur data ini. Anda diijinkan untuk menggunakan C++ STL priority_queue, Python heapq, atau Java PriorityQueue jika itu mempermudah implementasi anda.

Setelah menghabiskan satu kuliah panjang tentang Timbunan Biner (Maks), pernyataan berikutnya bisa mengejutkan anda...

Timbunan Biner (Maks) mungkin bukan struktur data terbaik untuk mengimplementasikan (beberapa operasi-operasi spesifik) dari ADT Antrian Berprioritas...

Diskusi: Jadi apakah data struktur alternatifnya?