Modul-8 : Algoritma dan Struktur Data




Binary heap digunakan sebagai struktur data
dalam algoritma Heap-Sort
Sebagaimana diketahui, ketika suatu Heap
dibangun maka kunci utamanya adalah: node
atas selalu mengandung elemen lebih besar
dari kedua node dibawahnya
Apabila elemen berikutnya ternyata lebih
besar dari elemen root, maka harus di “swap”
dan lakukan: proses “heapify” lagi
Root dari suatu Heap sort mengandung
elemen terbesar dari semua elemen dalam
Heap

Proses Heap-Sort dapat dijelaskan sbb:
1. Representasikan Heap dengan n elemen dalam
sebuah array A[n]
2. Elemen root tempatkan pada A[1]
3. Elemen A[2i] adalah node kiri dibawah A[i]
4. Elemen A[2i+1] adalah node kanan dibawah A[i]
5. Contoh: array A=[16 14 10 8 7 9 3 2 4 1]
mewakili binary-heap sbb:
6. Ambil nilai root (terbesar) A[1..n-1] dan
pertukarkan dengan elemen terakhir dalam array,
A[n]
7. Bentuk Heap dari (n-1) elemen, dari A[1] hingga
A[n-1]
8. Ulangi langkah 6 dimana indeks terakhir
berkurang setiap langkah.
1 16
2
4
14
5
8
28 8
4
3
10
9
16
6
7
1
14
10
9
7
3
10
8
7
9
3
2
4
1
1 16
2
4
14
5
9
38 8
2
3
10
9
16
6
8
1
14
10
7
7
4
10
9
8
7
4
3
2
1
MAX-HEAPIFY(A, i)
1 l ← LEFT(i)
2 r ← RIGHT(i)
3 if l ≤ heap-size[A] and A[l] > A[i]
4 then largest ← l
5
else largest ← i
6 if r ≤ heap-size[A] and A[r] > A[largest]
7
then largest ← r
8 if largest ≠ i
9 then exchange A[i] ↔ A[largest]
10
MAX-HEAPIFY(A, largest)
BUILD-MAX-HEAP(A)
1 heap-size[A] ← length[A]
2 for i ← ⌊length[A]/2⌋ downto 1
3 do MAX-HEAPIFY(A, i)
HEAPSORT(A)
1 BUILD-MAX-HEAP(A)
2 for i ← length[A] downto 2
3
do exchange A[1] ↔ A[i]
4
heap-size[A] ← heap-size[A] - 1
5
MAX-HEAPIFY(A, 1)

Analisis:
◦ Prosedur Heapify(i,j) adalah pembentukan binary
heap dengan kompleksitas O(log n)
◦ Kemudian prosedur ini dipanggil n kali (Build-MaxHeap) sehingga secara keseluruhan kompleksitas
adalah O(n log n)


Quick-sort adalah teknik pengurutan data
yang memiliki kerumitan rata-rata O(n log n)
tetapi dalam “worst-case” bisa mencapai
O(n2)
Teknik Quick-sort berbasis teknik divideand-conquer, sbb:
◦ Divide : array A[p..r] dibagi menjadi A[p..q] dan
A[q+1 ..r] sehingga setiap elemen A[p..q] lebih kecil
dari atau sama dengan setiap elemen A[q+1..r]
◦ Conquer : subarray A[p..q] dan A[q+1..r] juga disort menurut Quick-Sort
◦ Combine : pada akhirnya A[p..r] akan ber-urutan
QuickSort(A,p,r)
if (p < r)
then q  Partisi(A,p,r);
QuickSort(A,p,q);
QuickSort(A,q+1,r);
Partisi(A,p,r)
x  A[p]; i  (p-1); j  (r+1);
while (true) {
repeat (j j -1) until (A[j] <= x)
repeat (i  i+1) until (A[i] >= x)
if (i < j)
then Swap(A[i], A[j])
else Return (j)
}

Analisis:
◦ Worst-case : terjadi apabila partisi memberikan
q=(n-1), atau subarray pertama = A[1..n-1] dan
subarray kedua hanya 1 elemen A[n]
 T(n) = T(n-1) + (n), jadi T(1) = (1)
 Solusinya =
n
n
2

(
k
)


(
k
)


(
n
)


k 1
k 1
◦ Average-case : karena mengikuti divide-andconquer maka: T(n) = 2 T(n/2) + (n) sehingga
solusi-nya adalah O(n log n)


Radix sort biasa digunakan pada basis data
yang akan di-urutkan melalui kunci yang
berantai, misalnya akan diurutkan menurut
tanggal lahir, maka harus dilakukan sort 3
langkah, pertama menurut tahun, kemudian
menurut bulan, dan terakhir menurut tanggal
Pada sortir angka, maka radix sort diterapkan
pada setiap digit
RADIX-SORT(A, d)
1 for i ← 1 to d
2 do use a stable sort to sort array A on digit i
Copyright @2007, Suarga
The analysis of the running time depends on the stable
sort used as the intermediate sorting algorithm. When
each digit is in the range 0 to k-1 (so that it can take on
k possible values), and k is not too large, counting sort
is the obvious choice. Each pass over n d-digit numbers
then takes time Θ(n + k). There are d passes, so the
total time for radix sort is Θ(d(n + k)).
Copyright @2007, Suarga


Counting sort assumes that each of the n
input elements is an integer in the range 0 to
k, for some integer k. When k = O(n), the sort
runs in Θ(n) time.
In the code for counting sort, we assume that
the input is an array A[1 n], and thus
length[A] = n. We require two other arrays:
the array B[1 n] holds the sorted output, and
the array C[0 k] provides temporary working
storage.
Copyright @2007, Suarga
COUNTING-SORT(A, B, k)
1 for i ← 0 to k
2
do C[i] ← 0
3 for j ← 1 to length[A]
4
do C[A[j]] ← C[A[j]] + 1
5 ▹ C[i] now contains the number of elements equal
to i.
6 for i ← 1 to k
7
do C[i] ← C[i] + C[i - 1]
8 ▹ C[i] now contains the number of elements less
than or equal to i.
9 for j ← length[A] downto 1
10 do B[C[A[j]]] ← A[j]
11
C[A[j]] ← C[A[j]] - 1
Copyright @2007, Suarga
The operation of COUNTING-SORT on an input array A[1 8], where each
element of A is a nonnegative integer no larger than k = 5. (a) The array
A and the auxiliary array C after line 4. (b) The array C after line 7. (c)-(e)
The output array B and the auxiliary array C after one, two, and three
iterations of the loop in lines 9-11, respectively. Only the lightly shaded
elements of array B have been filled in. (f) The final sorted output array B.
Copyright @2007, Suarga
How much time does counting sort require?
The for loop of lines 1-2 takes time Θ(k), the
for loop of lines 3-4 takes time Θ(n), the for
loop of lines 6-7 takes time Θ(k), and the for
loop of lines 9-11 takes time Θ(n). Thus, the
overall time is Θ(k+n). In practice, we usually
use counting sort when we have k = O(n), in
which case the running time is Θ(n).
Copyright @2007, Suarga


Bucket sort runs in linear time when the input
is drawn from a uniform distribution. Like
counting sort, bucket sort is fast because it
assumes something about the input.
bucket sort assumes that the input is
generated by a random process that
distributes elements uniformly over the
interval [0, 1).
Copyright @2007, Suarga


The idea of bucket sort is to divide the
interval [0, 1) into n equal-sized subintervals,
or buckets, and then distribute the n input
numbers into the buckets.
Our code for bucket sort assumes that the
input is an n-element array A and that each
element A[i] in the array satisfies 0 ≤ A[i] < 1.
The code requires an auxiliary array B[0 n 1] of linked lists (buckets) and assumes that
there is a mechanism for maintaining such
lists.
Copyright @2007, Suarga
BUCKET-SORT(A)
1 n ← length[A]
2 for i ← 1 to n
3
do insert A[i] into list B[⌊n A[i]⌋]
4 for i ← 0 to n - 1
5
do sort list B[i] with insertion sort
6 concatenate the lists B[0], B[1], . . ., B[n - 1]
together in order
Copyright @2007, Suarga
The operation of BUCKET-SORT. (a) The input array
A[1 10]. (b) The array B[0 9] of sorted lists (buckets)
after line 5 of the algorithm. Bucket i holds values in
the half-open interval [i/10, (i + 1)/10). The sorted
output consists of a concatenation in order of the
lists B[0], B[1], . . ., B[9].
Copyright @2007, Suarga
the running time of bucket sort is
we conclude that the expected time for bucket sort
is Θ(n) + n · O(2 - 1/n) = Θ(n).
Copyright @2007, Suarga