DANDC wijanarto

Why SORT Banyak di pakai dalam aplikasi Database  binary sort Computer graphic dan komputasi geometri Closest pair dan keunikan suatu elemen

Algoritma Insertion dan selection sort : worst case O(n2) Heap sort (quick sort) : worst case O(n log n)

DIVEDE AND CONQUER Divide Conquer Combine Bagi masalah asli menjadi dua atau lebih sub problem yang unik Conquer Gunakan DANDC secara rekursif untuk menyelesaikan subproblem Combine Ambil solusi dari subproblem dan merge solusi tersebut ke dalam solusi untuk masalah aslinya

Merge sort Divide Conquer Combine Jika S memiliki setidaknya 2 elemen , pindahkan seluruh elemen S dan letakan dalam 2 urutan S1 dan S2, tiap urutan mengandung setengah dari S S1=n/2 elemen dan s2= sisanya  n/2  elemen Conquer SORT s1 dan s1 dengan merge sort Combine Kembalikan elemen tadi ke S dengan menggabungkan urutan yang telah di sort S1 dan S2 menjadi 1 urutan sort

Algoritma Merge Sort P dan r adalah Bagian dari array A, yaitu Lower bound dan upper bound Merge-Sort(A,p,r) If p<r then q(p+r)/2 Merge-Sort(A,p,q) Merge-Sort(A,q+1,r) Merge (A,p,q,r) divide conquer combine Merge(A,p,q,r) Ambil 2 elemen teratas yang terkecil dari A[p..q] Dan A[q+1..r], lalu letakan ke hasil pengurutan. Ulangi urutan (s1 dan s2) tersebut hingga kosong. Kopi hasil pengurutan ke dalam A[p..r]

contoh 85 24 63 45 85 24 63 45 17 31 50 96

Running algoritma 85 24 63 45 17 31 50 96 85 24 63 45

Running algoritma 85 24 63 45 17 31 50 96 85 24 63 45 85 24

Running algoritma 85 24 63 45 17 31 50 96 85 24 63 45 85 24 85

Running algoritma 85 24 63 45 17 31 50 96 85 24 63 45 24 85

Running algoritma 85 24 63 45 17 31 50 96 85 24 63 45 85 24

Running algoritma 85 24 63 45 17 31 50 96 63 45 24 85

Running algoritma 85 24 63 45 17 31 50 96 24 85 63 45

Running algoritma 85 24 63 45 17 31 50 96 24 85 63 45

Running algoritma 85 24 63 45 17 31 50 96 24 85 45 63

Running algoritma 85 24 63 45 17 31 50 96 24 85 45 63

Running algoritma 85 24 63 45 17 31 50 96 24 45 63 85

Running algoritma 85 24 63 45 24 45 63 85 17 31 50 96 24 45 63 85

Running algoritma 85 24 63 45 24 45 63 85 17 31 50 96 24 45 63 85 Langkah selanjutnya sama dengan bagian pertama

Merging 2 seq array 24 45 63 85 a S1 17 31 50 96 S2 S 24 45 63 85 b S1

Merging 2 seq array 45 63 85 c S1 31 50 96 S2 17 24 S 45 63 85 d S1 50

Merging 2 seq array 63 85 e S1 50 96 S2 17 24 31 45 S 63 85 f S1 96 S2

Merging 2 seq array 85 g S1 96 S2 17 24 31 45 50 63 S h S1 96 S2 17 24

Merging 2 seq array i S1 S2 17 24 31 45 50 63 85 96 S

Merge revisi Input 1 5 2 4 4 3 2 6 Untuk men-SORT sejumlah n 1 5 2 4 4 3 2 6 Untuk men-SORT sejumlah n Jika n=1 selesai Reccuren sort 2 list sejumlah  n/2  dan  n/2  elemen Merge 2 list tsb dlm O(n) Strategi Pecah masalah mjd subproblem yg mirip Reccuren sub masalah Combine solusi split 1 5 2 4 4 3 2 6 split split 1 5 2 4 4 3 2 6 split split split split 1 5 2 4 4 3 2 6 merge merge merge merge 1 5 2 4 4 3 2 6 merge merge 1 2 4 5 2 3 4 6 merge 1 2 2 3 4 4 6 6 output

C implementation void mergesort(int numbers[], int temp[], int array_size){ m_sort(numbers, temp, 0, array_size - 1); }  void m_sort(int numbers[], int temp[], int left, int right){ int mid; if (right > left) { mid = (right + left) / 2; m_sort(numbers, temp, left, mid); m_sort(numbers, temp, mid+1, right); merge(numbers, temp, left, mid+1, right);

C implementation void merge(int numbers[], int temp[], int left, int mid, int right){ int i, left_end, num_elements, tmp_pos; left_end = mid - 1; tmp_pos = left; num_elements = right - left + 1; while ((left <= left_end) && (mid <= right)) { if (numbers[left] <= numbers[mid]) { temp[tmp_pos] = numbers[left]; tmp_pos = tmp_pos + 1; left = left +1; } else

C implementation {temp[tmp_pos] = numbers[mid]; tmp_pos = tmp_pos + 1; mid = mid + 1; } } while (left <= left_end) { temp[tmp_pos] = numbers[left]; left = left + 1; tmp_pos = tmp_pos + 1; } while (mid <= right) { temp[tmp_pos] = numbers[mid]; mid = mid + 1; for (i=0; i <= num_elements; i++) { numbers[right] = temp[right]; right = right – 1; }

Quick Sort Karakteristik Sort dalam satu “tempat”, tidak perlu array tambahan Sangat praktis, avarage case O(n log n), worst case O (n2)

Prinsip Quick Sort Melihat deskripsi high level algorithm DANDC Divide Partisi array mjd 2 sub array s.r.s dalam bagian lower <= bagian higher Conquer Sort Recursive 2 sub array tadi Combine Sort selesai di “tempat” tadi

Partitioning (pembagian) wt=linear j i Partition(A,p,r) /*p & r batas array A*/ 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 and i<=r if i>=j break; Tukar(A[i],A[j]) Tukar(A[p],A[j]) Return j 17 12 6 19 23 8 5 10 p r x=10 i j 10 12 6 19 23 8 5 17 i j 10 5 6 19 23 8 12 17 j i 10 5 6 8 23 19 12 17 Mengembalikan posisi partisi dari array A

Algoritma Quick Sort Pemanggilan Quicksort(A,1,pjg[A]) Quicksort(A,p,r) if p<r then qPartition(A,p,r) Quicksort(A,p,q-1) Quicksort(A,q+1,r) Partisi array A antara p dan r

Analisa Quicksort Asumsikan semua elemen berbeda Running time tergantung dari distribusi spliting array Spliting partisi perlu waktu

Best case n n/2 n/4 lg n n/8 1 (n lg n) Running time tree adalah lg n, jadi total waktu tempuhnya adalah n lg n, Karena setiap level pada tree adalah n, Worst case = (n2)

Randomize Quicksort Asumsi semua elemen berbeda Partisi di pilih secara random dalam elemen Konsekuensinya semua split (1:n-1,1:n-2,…, n-1:1) mirip dengan probabilitas 1/n Randomisasi merupakan alat generalisasi untuk meningkatkan algoritma dengan worst case yang jelek tetapi bagus untuk avarage case

Randomize Quicksort RandomizePartition(A,p,r) iRandom(p,r)//generate angka //random antara p dan r Tukar(A[r],A[i]) return Partition(A,p,r) RandomizeQS(A,p,r) if p<r then qRandomizePartition(A,p,r) RandomizeQS(A,q+1,r)

Analisis Randomize Quicksort Misal T(n), adalah waktu yang di butuhkan dalam perbandingan dalam quicksort sejumlah n Karena split butuh probabilitas 1/n, maka T(n) bernilai = T(i-1)+T(n-i)+n-1, jadi Sehingga dg solving recc mjd O(n log n)

Analisis Randomize Quicksort Worstcase =O(n2) Bestcase=O(n log n) Expected running time quicksort O(n log n)

Searching Binary search Interpolasi search

Binary Search t[1..n] data tersortir menaik, t[i]t[j], dimana 1  i  j  n. X adalah elemen yang di cari dalam t, jika x tidak ada dalam t, maka kita dapat menyisipkannya ke t. Problem : mencari index I sedemikian rupa sehingga 1  i  j  n dan t[i-1]< x  t[i]

Binary Search dengan DANDC Binsearch (t[1..n],x) { if n==0 and x> t[n] then return n+1 else return Binrecc(t[1..n],x) } Binrecc (t[1..n],x) { /*mencari x dalam array t*/ /*untuk t[i-1]<x  t[j]*/ if i=j then return i k(i+j)\2 if x  t[k] then return Binrecc(t[1..k],x) else return Binrecc(t[k+1..j],x) }

Binary Search dengan DANDC Mencari x=12 dalam array t Binrecc (t[1..n],x) { if i=j then return i k(i+j)\2 if x  t[k] then return Binrecc(t[1..k],x) else return Binrecc(t[k+1..j],x) } 1 2 3 4 5 6 7 8 9 10 11 -5 -2 3 8 8 9 12 12 26 31 x t[k] ? i k j T i k j Y i k j Y i k j T i j i=j berhenti

Interpolasi Search