P. 1
operasi pengurutan

operasi pengurutan

|Views: 156|Likes:
Published by Lilik Prazzetyo

More info:

Published by: Lilik Prazzetyo on May 31, 2012
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as DOC, PDF, TXT or read online from Scribd
See more
See less

09/19/2014

pdf

text

original

1. SELECTION_SORT Ide algoritma ini amat sederhana.

Mencari data terkecil dari data set yang belum terurut dan disusun dalam data set terurut. Tentu, data set terurut pada mulanya kosong. Setelah satu demi satu data disusun maka akan terbentuk keterurutan tersebut. Dalam pengurutan ini kedua data set (terurut maupun yang belum) berada dalam array yang sama. Misalnya array tersebut adalah X, maka pada setiap saat terdapat i buah data terurut pada X[0], X[1], ..., X[i-1], dan data tak terurut pada X[i], X[i+1], ..., X[n-1]. Algoritma melakukan pencarian X[j] terkecil dari data set yang belum terurut tersebut, misalnya didapat X[m] lalu melakukan penukaran X[i] dengan X[m] sehingga kemudian sudah terurut i+1 buat data dalam X. Algoritma selengkapnya adalah:
for (i=0; i < n-2; i++) {

m = i; for (j = m+1; j < n-1; j++) { if (X[m] > X[j]) m = j; } if (m != i) { t = X[m]; X[m] = X[i]; X[i] = t; } } Dalam semua kondisi algoritma ini tepat akan melakukan iterasi luar sebanyak n-1 dan iterasi dalam sebanyak (n-i). Jumlah operasi "m = j;" bergantung pada kondisi data. Average case adalah setengah dari jumlah iterasi dalam yang dilakukan pada setiap iterasi luar, yang menghasilkan jumlah total 1/4 n2) operasi tersebut. Kompleksitas dari algoritma ini O(n2).  Algoritma SELECTION_SORT (A) For i ← 1 to n-1 do min j ← i; min x ← A[i] for j ← i+1 to n do if A[j] < min x then min j ← j min x ← A[j] A[min j] ← A[i] A[i] ← min x

cost ….. ….. ….. ….. ….. ….. ….. ….. …..

times …… …… …… …… …… …… …… …… ……

SourceCode dalam Pascal Program selection;
1

uses wincrt; const Nmax = 10000; type numbers = array[1..Nmax] of integer; var A : numbers; N,x : integer; procedure selectionSort(var A : numbers; N : integer); var i,j,min,temp : integer; begin for i := 1 to N-1 do begin min := i; for j := i+1 to N do begin if A[j] < A[min] then min := j; end; temp := A[i]; A[i] := A[min]; A[min] := temp; end; end; begin write('Masukkan jumlah data : '); readln(N); writeln; write('Data array (gunakan spasi untuk memisahkan masing2 data): '); for x := 1 to N do
2

begin read(A[x]); write(' ') end; writeln; selectionSort(A,N); write('Data terurut : '); for x := 1 to N do begin write(A[x], ' ') end; end.

Analisis Algoritma Jumlah operasi perbandingan elemen untuk setiap pass ke-I adalah: i = 1 → jumlah perbandingan = n – 1 i = 2 → jumlah perbandingan = n – 2 i = 3 → jumlah perbandingan = n – 3 i = k → jumlah perbandingan = n – k i = n – 1 → jumlah perbandingan = 1 Jumlah seluruh operasi perbandingan elemen-elemen larik adalah : T(n) = (n – 1) + (n – 2) + … + 2 + 1 = n(n-1)/2 Jumlah operasi pertukaran untuk setiap i dari 1 sampai n – 1, terjadi satu kali pertukaran elemen, sehingga jumlah operasi pertukaran seluruhnya adalah : T(n) = n – 1. Jadi, algoritma pengurutan maksimum membutuhkan n(n – 1 )/2 buah operasi perbandingan elemen dan n – 1 buah operasi pertukaran. Jika observasi tertahan akibat tidak ada data masukkan (kosong) maka berpengaruh pada kompleksitas waktu. Dalam kondisi worst case kompleksitas waktu secara kuadratik, tetapi dalam kondisi average case berbentuk logaritmik yaitu O(n log n). Ini memberikan implikasi bahwa waktu eksekusi dari algoritma selection sort tidak terpengaruh pada karakter data masukkan (setengah terurut atau tidak trurut sama sekali).
3

x[j] = x[j-1].. n-2 atau sampai tidak terjadi penukaran dalam suatu iterasi.. . yaitu x[j] > x[j-1].. j--) { if (x[j] < x[j-1]) { tmp = x[j].. Loop-for dilakukan hanya sampai ke i karena pada iterasi ke-i data dalam x[0].. …. pemeriksaan tsb..n-1 harus memenuhi keterurutan. SEQUENTIAL BUBBLESORT Ide dari algoritma ini sangat menarik. Apabila tidak memenuhi maka posisi kedua data harus ditukar. ….. …. Pada iterasi ke-i. for (j=n-1. untuk semua i=1. 4 cost ….. x[j-1] = tmp.. Setiap pasangan data: x[j] dengan x[j-1]. .... Oleh sebab itu iterasi hanya dilakukan untuk harga i=0.  Algoritma SEQUENTIAL BUBBLESORT (A) for i ← 1 to length [A] do for j ← length [A] downto i+1 do if A[A] < A[j-1] then Exchange A[j] ↔ A[j-1]  SourceCode dalam pascal program bubble. times …… …… …… …… . Grafik hasil percobaan 2. j > i. misalnya oleh bubble-sort dilakukan dari kanan ke kiri serta di dalam sejumlah iterasi. 1. x[i-1] merupakan yang paling kecil dan sudah terurut hasil pengeseran yang dilakukan setiap loop sebelumnya. dilakukan pula dalam loop-for sbb. Untuk pemrograman konvensional maka pemeriksaan-pemeriksaan pasangan tersebut harus dilakukan satu demi satu. x[1]... } } Loop-for tersebut akan menggeser bilangan terkecil ke posisi i.

procedure bubbleSort(var A : numbers. begin clrscr.Nmax] of integer. end. type numbers = array[1. readln(N). write('Data array (gunakan spasi untuk memisahkan masing2 data): ').temp : integer. end. var A : numbers. N : integer).uses wincrt. const Nmax = 10000. A[j-1] := temp. var i. begin for i := 1 to N-1 do begin for j := N-1 downto i+1 do begin if A[j] < A[j-1] then temp := A[j]. N. end. for x := 1 to N do begin 5 .x : integer. write('Masukkan jumlah data : ').. A[j] := A[j-1].j. writeln.

end...N). INSERTION-SORT Ide dari algoritma ini seperti layaknya yang dilakukan oleh pemain kartu. jadi pada suatu saat data x[0].  Analisis Algoritma Jumlah perbandingan yang dimuat sebanyak : 1 + 2 + 3+ …+ (n-1) = n(n-1)/2 = O(n2) Perbandingan tidak respektif terhadap himpunan data masukan. for x := 1 to N do begin write(A[x]. writeln. bubbleSort(A. dan dilanjutkan dengan kartu ke empat. ' ') end.x[i-1] 6 . apakah berkategori best atau worst  Grafik hasil percobaan 3.. write(' ') end. Mulai dari dua kartu terkiri diurutkan. lalu kartu ketiga dari kiri disisipkan pada posisi yang sesuai.read(A[x]). ke lima.. write('Data terurut : '). dst.

break.5. Dalam implementasinya pemeriksaan x[i] diefisienkan dengan menyimpan isi x[i] ke dalam suatu temporary variable. Sehingga kompleksitas best case adalah O(n). } } } Suatu variant mengurangi pemeriksaan j >= 0 dengan menambahkan sentinel di awal array...7.9.9.2. Sentinel tersebut berharga bilangan yang tak hingga negatif.. loop-for dalam dilakukan dalam jumlah iterasi yang bervariasi: best case adalah 1 kali (langsung keluar). dan worse case adalah i-1 kali yaitu jika disisipkan di x[0].. …. 7 akan disisipkan di antara 6 dan 9. kita harus melakukan inisialisasi dengan menggeserkan isi array satu posisi terlebih dahulu untuk dapat ditempati sentinel tersebut..5.6.  Algoritma INSERTION-SORT (A) for j ← 2 to length[A] do key ← A[j] ∆ Insert A[j] into the sorted sequence A[1.3. kemudian setiap x[j] di kirinya yang lebih besar dari t digeser ke kanan. hingga didapatkan kondisi j < 0 atau x[j] <= t. dan di akhir algoritma kita harus menggeserkan kembali ke posisi semula. sehingga menjadi 3..6. …. 5 akan disisipkan di antara 3 dan 6. j--) { if (t < x[j]) x[j+1] = x[j]. 2 akan disisipkan sebelum 3. i < n.6.7. j >= 0 && !stop. for (j =i-1. X[i] akan diselipkan di antara x[j] dan x[j+1] jika x[i] berharga di antara keduanya. times …… …… …… …… . worse-case adalah O(n2).5.9.. Masalahnya. ….6. dan selanjutnya belum terurut 5. i++) { t = x[i].j .1] i←j-1 while i > 0 and A[i] > key 7 cost ….sudah terurut.. else { x[j+1] = t.7. Contoh: Jika sudah terurut 3. sehingga menjadi 2. sehingga iterasi selalu berhenti.. sehingga menjadi 3.9. Jadi algoritma selengkapnya: for (i = 1.

Var n : Integer. Uses Crt. Var K : integer. {jumlah langkah} J : integer. …. J := K-1. Type Larik = Array [1... Const NMaks = 1000. If Temp < L[J] then L[J+1] := Temp Else 8 . While (Temp > L[J]) AND (J > 1) do Begin L[J+1] := L[J]. bil : Larik. { untuk penukaran nilai} Begin For K := 2 to N do Begin Temp := L[K]. { penelusuran array } Temp : integer. End. Procedure Insertion(var L:Larik.NMaks] of Integer. …. N:Integer)..do A[i+1] ← A[i] i ← i-1 A[i+1] ← key  …. J := J-1. …… …… …… SourceCode dalam pascal Program InsertionSortDescending..

ProsesUrut(bil.  Analisis Algoritma 9 . Write('Jumlah Data : '). Readln(n). Procedure ProsesUrut(L:Larik.' : '). end.k.N). Insertion(L. N:Integer). End.' '). For k := 1 to N do Begin Write(L[k]. L[J] := Temp. Readln. Writeln('Setelah Diurut menjadi'). End.n).Begin L[J+1] := L[J]. End. Begin For k := 1 to N do Begin Write('Data ke-'. End. Begin Clrscr. Var k : integer. Readln(L[k]). Writeln('Metode InsertionSort Descending'). End. End.

…. COUNTING_SORT  Algoritma COUNTING_SORT (A....Kondisi best case pada analisis insertion sort yaitu pengulangan dengan while-loop pada baris kelima di eksekusi hanya sekali untuk setiap j. …. hal ini terjadi jika diberikan array A yang siap diurutkan. …… …… …… …… . Keadaan ini terjadi jika array A-star keluar dari pemesanan. k) for i ← 1 to k do c[i] ← 0 for j ← 1 to n do c[A[j]] ← c[A[j]]+1 10 cost times …. sehingga jumlah iterasi sebanyak : T(n) = an + b = O(n) Persamaan diatas merupakan fungsi linier dari n. B. Kondisi worstcase pada analisis insertion sort yaitu terjadi karena baris kelima di eksekusi sebanyak j kali untuk setiap j. …. sehingga jumlah iterasi sebanyak: T(n) = an2 + bc + c = O(n2) Kompleksitas waktu berbanding dengan n2 (kuadratik)  Grafik hasil percobaan 4..

11 …. C[A[i]] := C[A[i]] .. Uses wincrt. Var i.j : integer.. for i:=1 to n do C[A[i]] := C[A[i]] + 1. var C : array [1. procedure CountingSort (A : TArray. end. end.. …. …. begin for i:=1 to k do C[i] := 0. i : integer.. begin end. for i:=2 to k do C[i] := C[i] + C[i-1].1. for i:=n downto 1 do begin B[C[A[i]]] := A[i]. …… …… …… …… …… . …..//c[i] now contains the number of elements equal to i for i ← 2 to k do c[i] ← c[i] + c[i-1] //c[i] now contains the number of elements ≤ i for j ← n downto 1 do B[c[A[i]]] ← A[j] c[A[i]] ← c[A[j]] – 1  SourceCode dalam Pascal Program counting. var B : TArray)..k] of byte. ….

Persamaan Big-O yang diperoleh dari proses ini adalah O(n). kalang kedua membutuhkan waktu O(n). Syarat agar pengurutan ini dapat dilakukan adalah diketahuinya rentang nilai data-datanya. Kondisi Worst-Case 12 . metode pengurutan ini sangat cepat dan efektif. Yang diimbangi dengan kelemahan yaitu dibutuhkan memori tambahan sebagai array bantu dalam prosesnya. misal dengan rentang 0. Counting sort melakukan pengurutan tanpa melakukan pembandingan antardata.100. Proses perbandingan pada kondisi ini hanya dilakukan sebanyak (n-1) kali. Data-data yang akan diurutkan juga harus berupa bilangan bulat (integer).. Dengan kompleksitas O(n). dan kalang keempat membutuhkan waktu O(n). Contoh di mana counting sort dapat menjadi efisien adalah bila mengurutkan siswa-siswa dalam sebuah sekolah berdasar nilainya. Dan contoh di mana counting sort akan sangat buruk kinerjanya adalah untuk data yang rentangnya sangat besar.232-1. Kondisi Best-Case Dalam kasus ini. Analisis Algoritma Waktu yang dibutuhkan untuk mengurutkan data menggunakan counting sort bisa didapatkan dari perhitungan sebagai berikut : Kalang pertama membutuhkan waktu O(k).. Di mana semakin besar k maka memori tambahan yang diperlukan menjadi sangat besar. yang seringkali dianggap k = O(n). Jadi secara total membutuhkan waktu O(k+n).. Counting sort bisa efisien bila k tidak jauh lebih besar daripada n. Proses perbandingan dilakukan hanya untuk memverifikasi keurutan data. dengan nilai adalah bilangan bulat dengan rentang 0. data yang akan disorting telah terurut sebelumnya. kalang ketiga membutuhkan waktu O(k). sehingga proses perbandingan hanya dilakukan sebanyak (n-1) kali. sehingga waktu total yang dibutuhkan menjadi O(n). dengan satu kali pass.

jumlah pass ditentukan dari elemen mana yang mengalami penggeseran ke kiri paling banyak. Jumlah proses = n2+n n adalah jumlah elemen yang akan diurutkan.Dalam kasus ini. data terkecil akan bergeser ke arah awal sebanyak satu step. untuk menggeser data terkecil dari urutan keempat menuju urutan pertama. Dalam hal ini. Sehingga notasi Big-O yang didapat adalah O(n2). dapat dilihat bahwa yang akan mengalami proses penggeseran paling banyak adalah elemen 2. Jumlah proses = x2+x x adalah jumlah penggeseran terbanyak. jumlah proses perbandingan dapat dihitung sebagai berikut. Dari (1 8 6 2). ditambah satu kali pass untuk memverifikasi. Jadi untuk mengurutkan diperlukan dua buah passing. ditambah satu buah passing untuk memverifikasi.  Grafik hasil percobaan 13 . Sehingga jumlah proses pada kondisi best case dapat dirumuskan sebagai berikut. dibutuhkan pass sebanyak tiga kali. Setiap kali melakukan satu pass. yaitu sebanyak dua kali. Dapat disimpulkan bahwa notasi big-O nya adalah O(n2). x tidak pernah lebih besar dari n. Hal ini dapat ditunjukkan oleh proses pengurutan suatu array. Dengan kata lain. Dengan kata lain. Kondisi Average-Case Pada kondisi average-case. data terkecil berada pada ujung array. misalkan saja (1 8 6 2).

. Kompleksitas dari algoritma ini secara worse case adalah dengan waktu O(n2) tetapi dengan pemilihan harga-harga D yang tepat dapat menghasilkan kompleksitas waktu yang kurang dari itu.. Walaupun Insertion Sort dalam kondisi normal merupakan algoritma O(n2). Partisi ini dilakukan dengan kriteria: • • • digunakan salah satu data sebagai pivot value sub data set kiri adalah data yang berharga <= pivot value sub data set kanan adalah data yang berharga > pivot value 14 . D2. . > Dh = 1. kita sebut sub data set kiri dan sub data set kanan. maka overhead cost untuk proses-proses tambahannya pun amat kecil sehingga untuk jumlah data n yang kecil masih bisa lebih cepat dari algoritma O(n log n). .. maka setiap X[i].. lebih tepatnya memanfaatkan kondisi-kondisi positif dari Insertion Sort.. Dengan demikian mendekati kondisi positif Insertion Sort kedua. Jika D=1 maka yang terjadi adalah Insertion Sort murni.. Dh. Quick Sort Ide dari algoritma ini adalah secara rekursif membagi (atau mempartisi) data set ke dalam dua sub data set. masing-masing diaplikasikan dengan cara di atas berturut-turut mulai dari yang terbesar hingga yang terkecil maka akhirnya terjadi hal-hal sebagai berikut: • • Saat D berharga besar maka terjadi sejumlah insertion sort pada subset-subset yang masing-masing dengan data berjumlah sedikit (n/D).. Dengan suatu bilangan integer positif D. dan ini adalah mendekati kondisi positif Insertion Sort pertama. X[i+2D. X[i+D]. dimasukkan dalam satu subset yang sama dari D subset yang ada. di mana D1 > D2 > .. Sejumlah harga D: D1.5. Untuk D yang kecil ukuran subset membesar namun akibat proses pada D sebelumnya dapat menyebabkan data sebagian terurut.: • • Insertion Sort bisa sangat efisien untuk data dalam kondisi hampir terurut. Karena Insertion Sort sangat sederhana. Pengurutan a'la Insertion Sort dilakukan pada masing-masing subset. Namun sejumlah literatur berdasarkan pengukuran eksperimental mendapatkan average case dengan waktu O(n1.Shell Sort Algoritma ini bisa dipandang sebagai modifikasi dari algoritma Insertion Sort.25). 6. algoritma ini memiliki keuntungan-keuntungan sbb.

15 . int right ). Setelah dilakukan pembagian tersebut maka algoritma Quick Sort diaplikasikan untuk masingmasing sub data set tsb dan seterusnya secara rekursif hingga terbentuk sub data set yang tidak dapat dibagi lagi yaitu jika hanya berisi satu sel (l = r). Kondisi worse case adalah jika partisi menghasilkan sub data set kosong dan yang lain besar (o(n2). Bagian yang paling tricky adalah pada pembagian data set. Contoh 2: #include <vector> #include <fstream> #include <classlib\timer. Kompleksitas algoritma Quick Sort adalah bergantung pada hasil partisi tersebut. void QuickSort(int l.r). //Two Separate functions have not been created due to memory restraints when using in1100. Kondisi average case adalah jika partisi menghasilkan sub data set yang balance (o(n log n)).r) yang menghasilkan t yaitu posisi pivotnya. } } Proses Partisi diserahkan kepada anda untuk mempelajarinya sendiri.txt int partition( vector<long> &array. Kondisi best case adalah jika dalam setiap partisi tidak dilakukan operasi pertukaran tempat dan pivot tepat berada ditengah subset (O(n)). algoritma Quick Sort adala sebagai berikut.h> using namespace std.int r) { if (l < r) { t = Partition(l. Maka. QuickSort(l.t-1). Walaupun demikian. Dalam beberapa literatur terdapat variant-varuant yang pada dasarnya terjadi karena perbedaan cara menentukan harga pivot: bisa data pertama (X[l]). data terakhir (X[r]) atau data ditengah (X[(l+r)/2]) data set). algoritma ini cenderung untuk average case. QuickSort(t+1. X[t] sendiri ditempati oleh pivot. kita sebut fungsi tersebut adalah Partition(l. int left.r).Jika data set berada dalam array X berindeks dari l sampai dengan r maka pembagian ini mempertukarkan sejumlah isi array sehingga sub data set kiri berada dalam array yang sama berindeks l sampai dengan t-1 dan sub data set kanan berada dalam array berindeks t+1 sampai dengan r.

vector<long> list.0. unsigned long numOfCompares = 0. timer.void quickSort( vector<long> &array. timer. vector<long> :: iterator i. i++ ) outfile << *i << endl. } infile.size() ). if( !infile ) { cerr << "Unable to open input file". while( infile >> number ){ list. quickSort( list. return 0.list. } TTimer timer. if( !outfile ) { cerr << "Unable to create output file". return 0. } ifstream infile( argv[1] ).Start(). unsigned long numOfSwaps = 0. } ofstream outfile( argv[2] ). int left. int right ).end(). 16 . for( i=list. int main( int argc. long number = 0.return 0.begin(). char* argv[] ) { if( argc != 3 ) { cerr << "Invalid number of paramemters".push_back( number ).close(). i<list.Stop().

close(). array[j] = v. 17 . outfile << "Swaps > " << numOfSwaps << endl. outfile << "Time > " << timer.outfile << endl. if( i == j ) break. int j =right. int left. array[i] = array[j].Time() << endl. outfile << "Comparisons > " << numOfCompares << endl. while( temp < array[--j] ){ numOfCompares++. long v = array[i]. } int partition( vector<long> &array. return 0. long temp = array[right]. int right ) { int i = left-1. } if( i >= j ) break. outfile. numOfSwaps++. while( true ) { while( array[++i] < temp ) numOfCompares++.

int i = partition( array. (l+r)/2)... numOfSwaps++. 7. Karena kedua data set itu bisa overlapping (tidak seperti pada Quick Sort) maka setelah kedua sub data set terurut masih memerlukan proses penggabungan (Merging).} array[right] = array[i]. Merging ini memerlukan ruang tambahan yaitu suatu array yang sama panjangnya dengan panjang kedua subset untuk menyimpan hasilnya. yaitu melakukan partisi. Sorting dilakukan dengan : 18 . X[r]) di partisi langsung ke du sub data set dengan jumlah data yang sama (X[l] .left.. MergeSort((l+r)/2. } void quickSort( vector<long> &array.right ). Kecuali bahwa algoritma ini melakukan partisi tanpa kriteria. array[i] = temp.left. Lalu secara rekursif melakukan Merge Sort untuk masing-masing data set.i+1. int left.. Radix Sort adalah algoritma O(n) dengan kompensasi diperlukan ruang tambahan untuk ruang kerjanya. Merging().right ). void MergeSort(int l.Radix Sort Berbeda dengan algoritma-algoritma di atas. dan X[(l+r)/2+1] . quickSort( array. int right ) { if( right <= left ) return. X[r]). quickSort( array.r). 8.i-1 ). X[(l+r)/2]. } } Algoritma ini memiliki kompleksitas O(n log n)..Merge Sort Ide algoritma ini hampir mirip dengan QuickSort.int r) { if (l < r) { MergeSort(l.. data set (X[l] . return i. Jadi.

576. Contoh untuk mengurutkan data: 121. 648. 764. 268. 823. 875. . 274. 548. 002. Setelah radix demi radix dilakukan. 434. 19 .• • membagi data set ke sub-sub data set sesuai dengan harga radixnya. Jika jumlah radix adalah d dan jumlah data adalah n maka operasi pengurutan ini memerlukan penempatan data dalam subset sebanyak dn kali yang berarti memiliki kompleksitas waktu O(n). atau bisa juga karakter ASCII (1 byte) dari data. Misalnya data berisi bilangan antara 000 sampai 999. 358. 824. mulai dari radix yang paling tidak signifikan ke yang paling signifikan. Digit terkanan adalah radix paling tidak signifikan. 637. sebaliknya jika r terlalu kecil maka akan diperlukan lebih banyak iterasi. Jadi diperlukan space tambahan untuk 2r*n data. kemudian menyatukannya subset subset tersebut menjadi satu set kembail (hanya mekonkatenasi) untuk dilakukan pembagian berikutnya berdasarkan radix yang lebih signifikan. 936. 367. 534. maka kemudian akan dihasilkan data terurut. maka ada 3 digit yang bisa digunakan sebagai radix (000. 076.. Contoh radix disini adalah digit-digit dari data. Pertama kali dibagi sesuai Kemudian dibagi sesuai digit terkanan: digit kedua: Subset#0: (kosong) Subset#0: (kosong) Subset#1: 121 Subset#1: (kosong) Subset#2: 232 742 Subset#2: 121 823 824 Subset#3: 823 Subset#3: 232 434 534 Subset#4: 824 434 274 936 736 637 764 534 Subset#4: 742 548 648 Subset#5: 875 Subset#5: 358 Subset#6: 076 936 736 Subset#6: 764 367 268 576 Subset#7: 274 875 076 Subset#7: 367 637 576 Subset#8: 268 548 648 Subset#8: (kosong) 358 Subset#9: (kosong) Subset#9: (kosong) Terakhir sesuai digit terkiri: Subset#0: 076 Subset#1: 121 Subset#2: 232 268 274 Subset#3: 358 367 Subset#4: 434 Subset#5: 534 548 576 Subset#6: 637 648 Subset#7: 736 742 764 Subset#8: 823 824 875 Subset#9: 936 Hasil penggabungannya Hasil penggabungannya adalah: 076 121 232 268 Hasil penggabungannya adalah: 121 823 824 232 274 358 367 434 534 548 adalah: 121 232 742 823 434 534 936 736 637 742 576 637 648 736 742 764 824 434 274 764 534 875 548 648 358 764 367 268 823 824 875 936 076 936 736 576 367 637 274 875 076 576 268 548 648 358 Dalam contoh tersebut pengetian radix adalah digit. 001. Yang perlu diperhatikan adalah jika radix berukuran r bit maka akan diperlukan 2r buah subset yang masing-masing harus disediakan dalam ukuran maksimumnya (yaitu sebanyak datanya).. 999). 742. dan digit terkiri adalah yang paling signifikan. Namun dicapainya waktu linear tersebut harus diiringi pertimbangan kebutuhan ruang yang besar. 232. Jika r terlalu besar jelas akan memakan banyak ruang. 736. Dalam penggunaannya bisa saja radix adalah dalam ukuran-ukuran 3 bit (oktal) dari data.

Versi ini mulai dengan sebuah heap kosong dan secara berturut-turut memasukkan data. Sebuah versi lain adalah membangun heap secara atas-bawah dan berganti-ganti ke atas untuk secara konseptual lebih sederhana untuk ditangani. Pada saat iterasi berada di level yang lebih tinggi. Hal ini diulang sampai array heap habis. yang kompleksitas algoritmanya pada kasus terburuk adalah O(n). secara berturut-turut berubah ke bawah untuk membangun heap. Bila kita mencoba operasi heapify dari akar maka akan terjadi operasi runut-naik seperti algoritma bubble sort yang akan menyebabkan kompleksitas waktu yang ada akan berlipat ganda. Algoritma ini bekerja dengan menentukan elemen terbesar (atau terkecil) dari sebuah daftar elemen. algoritma utama heapify adalah melakukan iterasi mulai dari internal simpul paling kanan bawah(pada representasi larik. dan seterusnya hingga mencapai akar (sebagai larik [0. pemeriksaan hanya dilakukan pada simpul anaknya langsung (tidak pada levellevel lain di bawahnya). adalah elemen yang berada di indeks paling besar) hingga akar. Setelah itu. sedangkan versi membentuk heap treeheap tree dari atas ke bawah kompleksitas nya O(n log n). lalu memindahkan data terbesar ke bagian belakang dari sebuah tabel hasil. heapify versi ini melakukan sebanyak N/2 kali iterasi. algoritma Heap Sort tidak memerlukan rekursif yang besar atau menggunakan banyak tabel (array). Versi lainnya lagi adalah dengan membentuk pohon heap-pohon heap mulai dari subtree-subtree yang paling bawah. algoritma ini memerlukan dua buah tabel. Setelah diuji. Walaupun lebih lambat dari Merge Sort atau Quick Sort. Jadi secara umum.Heap Sort Heap Sort adalah sebuah algoritma pengurutan yang paling lambat dari algoritma yang memiliki kompleksitas O(n log n). Tetapi tidak seperti algoritma Merge Sort dan Quick Sort. Dengan demikian. kasus yang paling buruk adalah restrukturisasi hanya akan mengalirkan simpul tersebut kearah bawah. Algoritma Heapify Algoritma Heapify adalah membangun sebuah heap dari bawah ke atas. dan satu tabel lainnya untuk menyimpan hasil. Pada simpul internal tersebut. 1. Heap sort menyelesaikan sebuah pengurutan menggunakan struktur data yang disebut heap. kemudian kearah kiri dan naik ke level di atasnya.9. Jika subtree-subtree suatu simpul sudah membentuk heap maka pohon dari simpul tersebut mudah dijadikan pohon heap dengan mengalirkannya ke bawah. Oleh karena itu. Heap Sort adalah pilihan yang baik untuk sebuah kumpulan data yang besar. algoritma ini cocok untuk digunakan pada data yang berukuran besar. Oleh karena itu. subtreesubtree selalu sudah membentuk heap. iterasi dilakukan mulai dari j= N/2 dan berkurang satu-satu hingga mencapai j=0. Jadi.N-1]).. 20 . Permasalahan pertama yang harus kita pertimbangkan dalam melakukan operasi heapify adalah dari bagian mana kita harus memulai. kemudian mengambil elemen terbesar untuk diletakkan di sebelah item yang telah dipindahkan tadi. array heap dibangun kembali. dan diletakkan pada akhir (atau awal) dari daftar tersebut. Jadi. Algoritma ini dimulai dengan membangun sebuah array heap dengan membangun tumpukan dari kumpulan data. dan pada kasus yang paling buruk akan melakukan iterasi sebanyak ²log(N) kali. maka ide yang paling efisien adalah versi yang terakhir. satu tabel untuk menyimpan heap.

dan 43. 16. simpul yang berada paling kanabawah dipindahkan ke akar untuk menggantikan simpul akar yang akan diambil. Dan setelah reheapify maka simpul yang akan diiterasikan berikutnya akan berkurang satu. 34. Hal ini disebabkan baik subtree kiri maupun subtree kanannya sudah merupakan heap. dan seterusnya berturut-turut hingga mencapai root (akar). lalu pertukaran 11 dengan 34. Subtree node ke-2: pertukaran 8 dengan 25 4. Algoritma Remove Algoritma remove ini menukar akar (yang berisi nilai maksimum) dari heap dengan elemen terakhir. serta akhirnya pertukaran 11 dengan 27 Perubahan-perubahan (pertukaran) tersebut dapat digambarkan sebagai berikut: 21 . Subtree node ke-4: pertukaran 16 dengan 43 2. Subtree node ke-1: pertukaran 9 dengan 43. 8. Secara logika. 9. 3. Dan elemen kelima dari array memiliki nilai indeks 4 sebab indeks array biasanya diawali dari 0. Perbedaan antara metode heapify dengan metode reheapify ada pada iterasi yang dilakukan oleh kedua algoritma tersebut. 25. Penerapan algoritma metoda heapify terhadap Complete Binary Tree (CBT) pada contoh di atas menghasilkan operasi-operasi pertukaran sebagai berikut: 1. 27.2. 13. Penerapan Algoritma Pengurutan Heap Sort Salah satu contoh penerapan algoritma pengurutan (sorting algorithm) heap sort adalah sebagai berikut: Misalkan terdapat suatu array bilangan bulat yang terdiri dari sepuluh buah anggota dengan nilai data 11. Subtree node ke-3: pertukaran 27 dengan 34 3. Algoritma metode reheapify ini hanya melakukan iterasi terakhir dari algoritma heapify. 12. lalu pertukaran 9 dengan 16 5. Pertama-tama. Algoritma Reheapify Algoritma reheapify ini melakukan pembuatan ulang heap dari atas ke bawah seperti halnya iterasi terakhir dari algoritma metoda heapify. Subtree node ke-0: pertukaran 11 dengan 43. sehingga tidak perlu dilakukan iterasi lengkap seperti algoritma heapify. Kita akan mengurutkan data diatas dengan menggunakan heapsort. ke-3. Iterasi dilakukan mulai dari node ke-4 karena N/2 dalam contoh di atas adalah 5. array di atas dapat dipandang sebagai suatu Complete Binary Tree (CBT) sebagai berikut: Selanjutnya algoritma metoda heapify dilakukan dengan iterasi dari subtree node ke-4.

9 dengan 27. 43. 22 . dan data yang telah terurut adalah 43.Semua perubahan di atas terjadi dalam array yang bersangkutan. Setelah 43 di-remove dan 9 menggantikan posisi yang ditinggalkan oleh 43. dan 11 dengan 16. Setelah 34 di-remove dan 11 menggantikan posisi yang ditinggalkan oleh 34. Sementara itu. dan 9 dengan 13. dalam iterasi yang melakukan/menerapkan algoritma metoda remove( ) dan algoritma metoda reheapify() akan terjadi pemrosesan berikut: 1. 2. maka terjadi reheapify: penukaran 9 dengan 34. sehingga pada akhirnya diperoleh tree terakhir yang merupakan heap tree. maka terjadi reheapify: penukaran 11 dengan 27. dan data yang telah terurut adalah 34.

//untuk menampilkan kelayar perintah untuk memasukkan element for(i=1.i++) //funsi for dimana jika ketentuan untuk i terpenuhi maka progran di bawahnya akan dijalankan { // pembuka fungsi for int temp. // untuk mengidentifikasikan nilai yang dimasukkan melalui keyboard printf(" Masukkan element : ").i).i. // a .n. 25. 34. 43. 12.int).k adalah integer printf(" Masukkan jumlah element : ").k. 13.j. // mendeklarasikan bahwa a[20] .int). Dan pada akhirnya akan didapatkan hasil data yang telah terurut adalah 8. 27.int.&n). i dalam fungsi restoreHup } // penutup fungsi for j=n. 34. 9. // nilai j sama dengan n for(i=1. Setelah 27 di-remove dan 9 menggantikan posisi yang ditinggalkan oleh 27. // temp sebagai integer temp=a[1].&a[i]). 11. // untuk mengidentifikasi array a restoreHup(a. //pemanggilan fungsi void restoreHdown void main() { // pembuka void main int a[20].i<=n. maka terjadi reheapify: penukaran 9 dengan 25. Demikian seterusnya dilakukan algoritma metoda remove dan algoritma metoda reheapify hingga tidak ada lagi node yang tersisa. dan data yang telah terurut adalah 27.i<=j. // temp sama dengan nilai array a yang pertama 23 . Program Heap Sort & Penjelasannya <#include <> void restoreHup(int*.j. // pemanggilan fungsi void restoreHup void restoreHdown(int*.n. 43.i.3. dan 9 dengan 12. 16.i++) //funsi for dimana jika ketentuan untuk i terpenuhi maka progran di bawahnya akan dijalankan { // pembuka fungsi for scanf("%d". 4.// untuk menampilkan kelayar perintah memasukkan jumlah element scanf("%d".

// nilai j akan selalu tambah 1 if(a[j] break. // nilai array a yg ke 1 sama dengan array a yang ke n a[n]=temp. "). // nilai array a yang ke n sama dengan nilay temp n--. // a .a[1]=a[n].i<=n. // v sama dengan nilai array a yang ke i while((i>1)&&(a[i/2] { // pembuka fungsi while a[i]=a[i/2].. // untuk menampilkan perintah ke dalam layar for(i=1.i++) //funsi for dimana jika ketentuan untuk i terpenuhi maka progran di bawahnya akan dijalankan printf("%4d".int i) // fungsi void restore Hup { // pembuka fungsi foid restoreHup int v=a[i].int i. // nilai array a yang ke i sama dengan nilai v } // penutup fungsi while void restoreHdown(int *a. // nilai array a yang ke j/2 sama dengan nilai array a yang ke j j=j*2.// nilai array a yang ke j/2 sama dengan v }// penutup fungsi void restorehdown //Suatu program untuk mengimplementasikan Heap Sort> Hasil Program diatas : 24 ..1.n). // nilai array a yang ke i sama dengan nilai array a yang ke i/2 i=i/2. 1.int n) // fungsi void restoreHdown { // pembuka fungsi void restoreHdown int v=a[i].// nilai j sama dengan i kali 2 ialah integer while(j<=n) // fungsi while akan dijalankan bila ketentuannya terpenuhi { // pembuka fungsi while if((j<n)&&(a[j]></n)&&(a[j]> j++. // nilai n selalu berkurang 1 restoreHdown(a. // nilai i sama dengan nilai i/2 } //penutup fungsi while a[i]=v. n dalam fungsi restoreHdown } // penutup fungsi for n=j. // nilai j sama dengan nilai j*2 }// penutup fungsi while a[j/2]=v. // v sama dengan nilai array a yang ke i sebagai integer int j=i*2. a[j/2]=a[j].a[i]). // n sama dengan nilai j printf(" Here is it. // untuk menampilkan nilai array ke i ke layar } // penutup void main void restoreHup(int *a.

} ifstream infile( argv[1] ). return 0. unsigned long &numOfSwaps ). unsigned long &numOfCompares. void shakerSort( vector<long>::iterator left. char* argv[] ) { if( argc != 3 ) { cerr << "Invalid number of paramemters". vector<long>::iterator right ).h> using namespace std. if( !infile ) { cerr << "Unable to open input file". traversal secara inorder pada BST dan menyimpannya dalam array akan menghasilkan array dengan data terurut. maka Tree Sort melakukan penyisipan tanpa menggeseran dengan digunakannya suatu struktur tambahan Binary Search Tree. Untuk n data operasinya adalah O(n log n + n) = O(n log n).10. Seperti yang kita ketahui kompleksitas operasi penyisipan pada BST adalah O(log n) dan operasi traversal adalah O(n). int main( int argc. 25 } . Setelah seluruh data masuk dalam BST. membutuhkan banyak operasi penggeseran. return 0. algoritma ini kurang populer karena adanya kebutuhan ruang untuk BST #include <vector> #include <fstream> #include <classlib\timer.Shaker Sort Jika Shaker Sort yang melakukan penyisipan dalam array data ybs. void shakerCount( vector<long> array. Walaupun kompleksitasnya ini adalah O(n log n).

begin(). outfile << "Time outfile. } TTimer timer.numOfSwaps ). . while( infile >> number ) { list. outfile << "Swaps > " << numOfSwaps << endl. if( !outfile ) { cerr << "Unable to create output file".Stop(). shakerCount( list.close().end(). i++ ) outfile << *i << endl.Time() << endl.begin().numOfCompares. vector<long> :: iterator i. outfile << "Comparisons > " << numOfCompares << endl.list. outfile << endl. timer.end() ). for( i=list. unsigned long numOfCompares = 0. } void shakerCount( &numOfSwaps ) vector<long> array. i<list.close(). vector<long> list. unsigned 26 long &numOfCompares. long number = 0. unsigned long numOfSwaps = 0. timer.Start(). shakerSort( list. return 0.push_back( number ). } infile.ofstream outfile( argv[2] ). return 0. unsigned long > " << timer.

swap = false. j<right.) 27 . *j ^= *(j+1). *j ^= *(j+1). vector<long>::iterator right = array. vector<long>::iterator k. k-. for( k=right-1. } } if( !swap ) break. vector<long>::iterator left = array. if( *j > *(j+1) ) { swap = true. vector<long>::iterator j.end()-1. numOfSwaps++.{ bool swap = false. k>left.begin(). while( right > left ) { swap = false. *(j+1) ^= *j. for( j=left. j++ ) { numOfCompares++.

left++. j<right. } } void shakerSort( vector<long>::iterator left. j++ ) 28 . vector<long>::iterator right ) { bool swap = false. vector<long>::iterator j. *k ^= *(k-1). if( *k < *(k-1) ) { swap = true. vector<long>::iterator k. numOfSwaps++. while( right > left ) { swap = false. *(k-1) ^= *k. } } if( !swap ) break. *k ^= *(k-1).{ numOfCompares++. for( j=left. right--.

*(k-1) ^= *k. k>left. k-. *j ^= *(j+1). for( k=right-1. *(j+1) ^= *j.{ if( *j > *(j+1) ) { swap = true. right--. left++. } } if( !swap ) break. } } if( !swap ) break. *k ^= *(k-1). swap = false. *j ^= *(j+1). *k ^= *(k-1). } 29 .) { if( *k < *(k-1) ) { swap = true.

} 30 .

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->