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

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

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

' ') end. write('Data terurut : ').  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. dan dilanjutkan dengan kartu ke empat.read(A[x]). INSERTION-SORT Ide dari algoritma ini seperti layaknya yang dilakukan oleh pemain kartu. jadi pada suatu saat data x[0].. apakah berkategori best atau worst  Grafik hasil percobaan 3. writeln.x[i-1] 6 .... for x := 1 to N do begin write(A[x]. ke lima.N). dst. write(' ') end. lalu kartu ketiga dari kiri disisipkan pada posisi yang sesuai. bubbleSort(A. end. Mulai dari dua kartu terkiri diurutkan.

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

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

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

sehingga jumlah iterasi sebanyak : T(n) = an + b = O(n) Persamaan diatas merupakan fungsi linier dari n. hal ini terjadi jika diberikan array A yang siap diurutkan. sehingga jumlah iterasi sebanyak: T(n) = an2 + bc + c = O(n2) Kompleksitas waktu berbanding dengan n2 (kuadratik)  Grafik hasil percobaan 4.Kondisi best case pada analisis insertion sort yaitu pengulangan dengan while-loop pada baris kelima di eksekusi hanya sekali untuk setiap j. …. …. Keadaan ini terjadi jika array A-star keluar dari pemesanan.. COUNTING_SORT  Algoritma COUNTING_SORT (A. …… …… …… …… ... 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 …. B.. …. Kondisi worstcase pada analisis insertion sort yaitu terjadi karena baris kelima di eksekusi sebanyak j kali untuk setiap j.

var C : array [1.. …. i : integer. end.. …. for i:=n downto 1 do begin B[C[A[i]]] := A[i]. end. 11 ….j : integer. …..k] of byte. var B : TArray). …...//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. for i:=2 to k do C[i] := C[i] + C[i-1]. …… …… …… …… …… . for i:=1 to n do C[A[i]] := C[A[i]] + 1. begin end. begin for i:=1 to k do C[i] := 0.1.. Uses wincrt. procedure CountingSort (A : TArray. Var i. C[A[i]] := C[A[i]] .

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

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

. di mana D1 > D2 > . Walaupun Insertion Sort dalam kondisi normal merupakan algoritma O(n2).25).. 6. X[i+D]. Untuk D yang kecil ukuran subset membesar namun akibat proses pada D sebelumnya dapat menyebabkan data sebagian terurut. Karena Insertion Sort sangat sederhana. X[i+2D. Quick Sort Ide dari algoritma ini adalah secara rekursif membagi (atau mempartisi) data set ke dalam dua sub data set..5.. 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.. kita sebut sub data set kiri dan sub data set kanan. 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).: • • Insertion Sort bisa sangat efisien untuk data dalam kondisi hampir terurut. lebih tepatnya memanfaatkan kondisi-kondisi positif dari Insertion Sort. D2. dimasukkan dalam satu subset yang sama dari D subset yang ada. > Dh = 1... 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]. Pengurutan a'la Insertion Sort dilakukan pada masing-masing subset. 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 . Dengan demikian mendekati kondisi positif Insertion Sort kedua.. Dengan suatu bilangan integer positif D. . algoritma ini memiliki keuntungan-keuntungan sbb. Namun sejumlah literatur berdasarkan pengukuran eksperimental mendapatkan average case dengan waktu O(n1. Dh. Sejumlah harga D: D1. dan ini adalah mendekati kondisi positif Insertion Sort pertama.Shell Sort Algoritma ini bisa dipandang sebagai modifikasi dari algoritma Insertion Sort. Jika D=1 maka yang terjadi adalah Insertion Sort murni..

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

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

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

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

Dalam penggunaannya bisa saja radix adalah dalam ukuran-ukuran 3 bit (oktal) dari data. mulai dari radix yang paling tidak signifikan ke yang paling signifikan. 19 . Contoh untuk mengurutkan data: 121.. 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.. 648. 999). Jika r terlalu besar jelas akan memakan banyak ruang. 268. 548. 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). 576. Contoh radix disini adalah digit-digit dari data. 823. 824. 274. 002. 367. maka ada 3 digit yang bisa digunakan sebagai radix (000. 736.• • membagi data set ke sub-sub data set sesuai dengan harga radixnya. dan digit terkiri adalah yang paling signifikan. atau bisa juga karakter ASCII (1 byte) dari data. maka kemudian akan dihasilkan data terurut. kemudian menyatukannya subset subset tersebut menjadi satu set kembail (hanya mekonkatenasi) untuk dilakukan pembagian berikutnya berdasarkan radix yang lebih signifikan. 358. 637. 764. 875. 232. 936. Misalnya data berisi bilangan antara 000 sampai 999. 076. . Jadi diperlukan space tambahan untuk 2r*n data. sebaliknya jika r terlalu kecil maka akan diperlukan lebih banyak iterasi. 742. 434. Namun dicapainya waktu linear tersebut harus diiringi pertimbangan kebutuhan ruang yang besar. 001. 534. Setelah radix demi radix dilakukan. Digit terkanan adalah radix paling tidak signifikan. 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).

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

9. dan seterusnya berturut-turut hingga mencapai root (akar). Dan elemen kelima dari array memiliki nilai indeks 4 sebab indeks array biasanya diawali dari 0. Hal ini disebabkan baik subtree kiri maupun subtree kanannya sudah merupakan heap. Iterasi dilakukan mulai dari node ke-4 karena N/2 dalam contoh di atas adalah 5. Subtree node ke-2: pertukaran 8 dengan 25 4. 8. 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. 34. 25. Dan setelah reheapify maka simpul yang akan diiterasikan berikutnya akan berkurang satu. simpul yang berada paling kanabawah dipindahkan ke akar untuk menggantikan simpul akar yang akan diambil.2. 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. Perbedaan antara metode heapify dengan metode reheapify ada pada iterasi yang dilakukan oleh kedua algoritma tersebut. Pertama-tama. 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 . lalu pertukaran 11 dengan 34. 27. 3. Subtree node ke-1: pertukaran 9 dengan 43. Secara logika. Algoritma Reheapify Algoritma reheapify ini melakukan pembuatan ulang heap dari atas ke bawah seperti halnya iterasi terakhir dari algoritma metoda heapify. Subtree node ke-3: pertukaran 27 dengan 34 3. Kita akan mengurutkan data diatas dengan menggunakan heapsort. Subtree node ke-4: pertukaran 16 dengan 43 2. 13. Subtree node ke-0: pertukaran 11 dengan 43. 12. lalu pertukaran 9 dengan 16 5. dan 43. ke-3. 16. sehingga tidak perlu dilakukan iterasi lengkap seperti algoritma heapify. Penerapan algoritma metoda heapify terhadap Complete Binary Tree (CBT) pada contoh di atas menghasilkan operasi-operasi pertukaran sebagai berikut: 1. Algoritma metode reheapify ini hanya melakukan iterasi terakhir dari algoritma heapify.

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

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

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

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

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

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

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

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

} 30 .

Sign up to vote on this title
UsefulNot useful