(Binary) Heap. Binary tree yang menyimpan pasangan prioritas (atau prioritas elemen) pada node Property Heap :

heap wijanarto

(Binary) Heap Binary tree yang menyimpan pasangan prioritas (atau prioritas elemen) pada node Property Heap : Struktural Semua level kecuali yang terakhir berisi penuh, level terakhir boleh tidak penuh (berisi anak) tetapi harus terisi. Heap Prioritas (elemen) node setidaknya sama atau sebesar parentnya (nilai elemen dalam heap)

(Binary) Heap 7 7 4

Bukan Heap Heap Violated 7 4

Bukan Heap Level terakhir Ada yang kosong 7 7 4 Level terakhir seharusnya ada 4 node saja

Menemukan elemen Terkecil Elemen dengan prioritas terkecil selalu berada pada posisi root dalam heap Hal ini karena jika tidak maka prioritas tersebut akan menjadi parent dengan prioritas lebih kecil dan hal ini melanggar heap property Dengan demikian findmin() dapat di lakukan selama waktu O()

Menemukan elemen Terkecil Findmin(a[]) return a[];

Height dari Heap Diberikan heap dengan n Node dan ketinggian (height) h Recall: Complete Binary Tree dengan Height h memiliki h+- node Dengan demikian h-<=h+- n= log h

Implementasi Heap Parent (i){return i/ } Left(i){return i} Right(i){rreturn i+} 7 Parent(5) (7) 7 Left() () Right() 7 7) 4 A Heap property : A[parent(i)]<=A[i] 4 5 7 0 7 Level 0 7 4

Implementasi Heap Secara implisit tree dalam link, dengan anak node i adalah i dan i+ Kenapa hal ini bermanfaat? Dalam representasi binary, perkalian atau pembagian dengan merupakan pergeseran ke kanan atau ke kiri (a** == shl(a) atau a//==shr(a)) Menambah sama dengan menambah pada bit terendah

Penyisipan dalam Heap Sisipkan 7 7 4 ra struktur maka kita akan tambahkan node Secara struktur sudah benar vel terakhir Tetapi secara heap tree ini bukan heap (krn < dari parent) Shg kita harus menukarnya

Penyisipan dalam Heap Sisipkan Sisipkan 7 7 4

Penyisipan dalam Heap Sisipkan Sisipkan 7 4 7

Cara menyisipkan lainnya Perbesar heap emakai jalur dari root tk menyisipkan node 7 7 4

Cara menyisipkan lainnya Perbesar heap emakai jalur dari root tk menyisipkan node mukan elemen dengan ioritas tertinggi yang bih besar dari emen yang an di sisipkan 7 7 4 Sisipkan elemen pada lokasi tersebut dan geser ke bawah elemen lainnya sesuai jalur yang di pilih

Cara menyisipkan lainnya 7 7 4

Kebenaran Insertion Node yang isinya berubah berada pada path 7 7 4

Kebenaran Insertion Node yang isinya berubah berada pada path Heap property terlanggar hanya pada node anaknya 7 7 4

Kebenaran Insertion Node yang isinya berubah berada pada path Heap property terlanggar hanya pada node anaknya Isi yang baru berprioritas lebih kecil dari sebelumnya 7 7 4

Kebenaran Insertion Node yang isinya berubah berada pada path Heap property terlanggar hanya pada node anaknya Isi yang baru berprioritas lebih kecil dari sebelumnya Shg heap property aman 7 7 4

Heapify(i) i adalah index array A Binary tree yang berakar di Left(i) dan Right(i) adalah heap Tetapi, A[i] harus lebih besar dari anaknya, sehingga terjadi violated pada heap property Fungsi Heapify membuat binary tree berakar di i pd heap dengan memindahkan A[i] ke bawah heap

Heapify Ini bukan heap Heap property violated pada node dg index tetapi Subtree pada akar dan adlaah heap Heapify () 7 0 4 Ini heap

Cara kerja Heapify Heapify akan melihat dua anak dari root yang violated Memilih prioritas pada kedua anak tersebut yang terkecil, lalu menukar 7 dengan rootnya 0 4

Cara kerja Heapify Heapify akan melihat dua anak dari root yang violated Memilih prioritas pada kedua anak tersebut yang terkecil, lalu menukar 0 dengan rootnya 7 4

Cara kerja Heapify lainnya Heapify(i) melacak path tree ke bawah 7 0 4

Cara kerja Heapify lainnya Heapify(i) melacak path tree ke bawah Node terakhir pada path (misal j) memiliki baik A[left(j)], A[right(j)] 7 yang lebih besar dari A[i] 0 4

Cara kerja Heapify lainnya Heapify(i) melacak path tree ke bawah Node terakhir pada path (misal j) memiliki baik A[left(j)], A[right(j)] yang lebih besar dari A[i] Seluruh elemen path 7 Memiliki prioritas lebih kecil dari saudaranya 0 4

Cara kerja Heapify lainnya Heapify(i) melacak path tree ke bawah Node terakhir pada path (misal j) memiliki baik A[left(j)], A[right(j)] yang lebih besar dari A[i] Seluruh elemen path Memiliki prioritas lebih kecil dari saudaranya Seluruh elemen pd path ini di pindahkan ke atas 0 7 4

Cara kerja Heapify lainnya Heapify(i) melacak path tree ke bawah Node terakhir pada path (misal j) memiliki baik A[left(j)], A[right(j)] yang lebih besar dari A[i] Seluruh elemen path Memiliki prioritas lebih kecil dari saudaranya Seluruh elemen pd path ini di pindahkan ke atas A[i] pindah ke posisi j 0 7 4

Run Time Analisis Heap dengan n node mempunyai height O(log n) Selama penyisipan kita harus memindahkan elemen ke atas Dengan demikian setidaknya di perlukan O(log n) langkah Dalam Heapify, elemen hrs di pindahkan ke akhir level, dan dengan demikian heapify perlu O(log n) langkah juga

Operasi Binary Heap Delete-Min Building heap dalam O(n) time Heapsort

Delete Minimum Elemen minimum adalah elemen pada top heap Kita dapat menghapus elemen tersebut dan memindahkan anaknya ke atas untuk mengisi ruang yang kosong karena penghapusan tadi Ruang yang kosong pada tree di pindahkan ke bawah Di akhiri pada setiap posisi pada akhir level Hasilnya tree menjadi tidak ada yang kosong pada akhir levelnya

Delete-min dalam heap 0 4 7

Delete-min dalam heap 0 4 7 Pelanggaran terhadap property struktur

Delete-min dalam heap () Ganti elemen top dengan elemen terakhir dalam heap 0 4 7

Delete-min dalam heap () Ganti elemen top dengan elemen terakhir dalam heap 7 Lakukan Heapify() 0 4

Delete-min dalam heap () Ganti elemen top dengan elemen terakhir dalam heap 0 Lakukan Heapify() 7 4

Building Heap Dimulai dari bawah ke atas Semua leaves adalah heap Build-Heap (A) for i n/ downto do Heapify(A,i) 4 en leaves berupa heap i mulai dari parent leaves terakhir 0 7

Building Heap Dimulai dari bawah ke atas Semua leaves adalah heap Build-Heap (A) for i n/ downto do Heapify(A,i) 4 en leaves berupa heap i mulai dari parent leaves terakhir 0 kukan Heapify (pada node tsb) 7

Building Heap Dimulai dari bawah ke atas Semua leaves adalah heap Build-Heap (A) for i n/ downto do Heapify(A,i) 4 en leaves berupa heap i mulai dari parent leaves terakhir 0 7 kukan Heapify (pada node tsb)

Building Heap Dimulai dari bawah ke atas Semua leaves adalah heap Build-Heap (A) for i n/ downto do Heapify(A,i) en leaves berupa heap i mulai dari parent leaves terakhir 0 4 7 kukan Heapify (pada node tsb)

Building Heap Dimulai dari bawah ke atas Semua leaves adalah heap Build-Heap (A) for i n/ downto do Heapify(A,i) en leaves berupa heap i mulai dari parent leaves terakhir 0 7 kukan Heapify (pada node tsb) 4

Building Heap Dimulai dari bawah ke atas Semua leaves adalah heap Build-Heap (A) for i n/ downto do Heapify(A,i) 0 en leaves berupa heap i mulai dari parent leaves terakhir 7 kukan Heapify (pada node tsb) 4

Analisis Building heap Kebenaran : induksi pada i, semua akar tree pada m>i adalah heap Run time : n call pada Heapify = n O(log n)=o(n log n) Height node : panjang dari jalur terpanjang dari node ke leaf Height tree: height node Time Heapify(i)=O(height of subtree berakar i) Asumsi : jum node n=k- (complete binary tree)

Analisis Building heap () Untuk n/ node dngan height, heapify membutuhkan setidaknya kali tukar Untuk n/4 node dngan height, heapify membutuhkan setidaknya kali tukar Untuk n/i node dngan height i, heapify membutuhkan setidaknya i kali tukar Jadi total jumlah pertukaran : = = = = = + = + + + + + + + = n i n n i n n O i i i karena i n O k n n n O n T log log ) ( ) / ( / ). (..... 4 ) (

Bagaimana terjadi O(n)? = = = = = = = = = < = 0 0 0 0 4 / / // ) ( // ) ( // i i i i i i i i i x masukan x x x x i x kalikan x x i diferensiasi x if x x Jadi O(n)

Heapsort Buat heap Lakukan delete-min Secara berulang hingga Heap mjd kosong 0 Lakukan sort pada, array 7 Pindahkan (tukar) elemen yang di hapus 4 di akhir heap

Proses heapsort Delete-min 0 7 4

Proses heapsort Heapify () 0 7 4

Proses heapsort Delete-min 0 7 4 Dihapus dengan delete-min Menghasilkan elemen tersortir

Proses heapsort Heapify() 7 4 0 Dihapus dengan delete-min Menghasilkan elemen tersortir

Proses heapsort Delete-Min 4 7 0 Dihapus dengan delete-min Menghasilkan elemen tersortir

Proses heapsort Hepaify() 4 7 0 Dihapus dengan delete-min Menghasilkan elemen tersortir

Run time operasi heap Insert():O(log n) Heapify(): O(log n) Findmin(): O() Deletemin(): O(log n) Buildheap(): O(n) Heapsort(): O(n log n)

Psuedo code PARENT(i) return i/ LEFT(i) return i RIGHT(i) return i +

Tukar Tukar (a,b) temp=a a=b b=temp

Heapify HEAPIFY(A, i) l LEFT(i) r RIGHT(i) if l <=heap-size[a] and A[l] > A[i] then largest l else largest i If r <=heap-size[a] and A[r] > A[largest] then largest r if largest!= i then exchange A[i]<--> A[largest] HEAPIFY(A,largest)

Shiftdown ShiftDown(A,i) k i repeat j k if j<=length(a) and A[j]>A[k] then k j if j<length(a) and A[j+]>A[k] then k j+ Tukar (A[j],A[k]) until j==k

Shiftup Shiftup(A,i) k i repeat j k if j>i and A[j%]<A[k] then k j% Tukar(A[j],A[k]) until j==k

Buildheap dan Makeheap BUILDHEAP(A) heap-size[a] length[a] for i length A/ downto do HEAPIFY(A, i) Atau Makeheap(A) for (i A/ ) downto ShiftDown(A,i)

FindMax-min, DelMax-min Findmax(A) return A[]; FindMin(A) return A[n] DelMax(A) A[] A[n] ShiftDown(A[..n-],) DelMin(A) A[n] A[] ShiftUp(A[..n-],n)

InsertNode InsertNode(A,v) A[n+] v Shiftup(A[..n-],n+)

Heapsort Heapsort (A) makeheap(a) for i n downto do tukar(a[],a[i]) Shiftdow(A[..i-],) Atau HEAPSORT(A) BUILDHEAP(A) for i length[a] downto do tukar(a[],a[i]) heap-size[a] heap-size[a]- HEAPIFY(A, )