Struktur Data – Implementasi Quick Sort Menggunakan C/C++Posted on 3 Januari 2010       6 Votes

B ahan Ajar/modul matakuliah Struktur Data ini membahas konsep tentang salah satu metode pengurutan  Quick Sort. Materi membahas mulai dari pengertian Quick Sort, pseudocode Quick Sort, analisis algoritma Quick Sort dan dDiakhir sesi dapat dilihat implemetasi Quick Sort Menggunakan C/C++.

Pengertian Quick Sort

Algoritma sortir yang efisien yang ditulis oleh C.A.R. Hoare pada 1962. Dasar strateginya adalah “memecah dan menguasai”. Quicksort dimulai dengan menscan daftar yang disortir untuk nilai median. Nilai ini, yang disebut tumpuan (pivot), kemudian dipindahkan ke satu sisi pada daftar dan butir-butir yang nilainya lebih besar dari tumpuan di pindahkan ke sisi lain.

Algoritma Quick Sort

Divide

Memilah rangkaian data menjadi dua sub-rangkaian A[p…q-1] dan A[q+1…r]  dimana setiap elemen A[p…q-1] adalah kurang dari atau sama dengan A[q]  dan  setiap   elemen  pada A[q+1…r]   adalah  lebih  besar   atau  sama  dengan elemen  pada  A[q].  A[q]   disebut   sebagai   elemen   pivot.   Perhitungan  pada elemen q merupakan salah satu bagian dari prosedur pemisahan.

Conquer

Mengurutkan elemen pada sub-rangkaian secara rekursif  Pada algoritma quick sort, langkah ”kombinasi” tidak di lakukan karena telah terjadi  pengurutan elemen – elemen pada sub array.

Pseudocode Quick Sort

Contoh Quick Sort

Analisis Algoritma QuickSort

Setiap elemen yang akan disort selalu diperlakukan secara sama di sini, diambil salah satu elemen, dibagimenjadi  3 list, lalu ketiga list tersebut disort dan digabung kembali. Contoh kode di atas menggunakan3 buah list, yaitu yang lebih besar, sama dan lebih  kecil nilainya dari pivot. Untuk membuat lebih efisien,bisa digunakan 2 buah list dengan mengeliminasi yang  nilainya sama (bisa digabung ke salah satu dari 2 listyang lain).  Kasus terburuk dari algoritma ini adalah saat dibagi menjadi 2 list, satu list hanya terdiri dari 1 elemen dan yang lain terdiri dari n-2 elemen. Untuk kasus terburuk dan kasus rata-rata, algoritma ini memiliki kompleksitas sebesar O(n log n). Jumlah rata-rata

perbandingan untuk quick sort berdasarkan permutasinya dengan asumsi bahwa nilai pivot diambil secara random adalah :

Lalu bagaimana cara menentukan pivot sendiri? Kasus terbaik yang diharapkan diilustrasikan sebagai berikut:

Bagi sebuah list menjadi 4 buah. Lalu pilih 2 buah list sedemikian rupa sehingga setiap elemennya lebih besar dari 25 % elemen terkecil dan lebih kecil dari 25% elemen  terbesar. Bila nilai pivot yang dipilih secara konstan terambil dari nilai ini maka hanya diperlukan pembagian list sebanyak 2log2n kali.Biladibandingkan dengan merge sort, quick sort memiliki keuntungan di kompleksitas waktu sebesar Θ(log  n), dibanding dengan merge sort sebesar  Θ(n). namun quick sort tidak mampu membandingkan  linked list sebaik merge sort, karena ada kemungkinan pemilihan pivot yang buruk. Selain itu pada   linked list merge sort memerlukan ruang yang lebih sedikit. Berdasarkan analisis tersebut quick sort termasuk algoritma sorting yang cukup baik, namun kita pun harus bisa memilih nilai pivot yang baik agar penggunaannya bisa optmal.

Implementasi Quic Sort Menggunakan C/C++

01 Partition(A, p, r)

02 x = A[p]; //pivot=elemen posisi pertama03 i = p ; //inisialisasi

04 j = r ;

05 repeat

06   while(A[j] > x)

07     j--;

08     while(A[i] < x)

09        i++;

10    if (i < j){11      Swap(A, i, j);

12      j--;

13      i++

14     }

15   else

16     return j;17 until i >= j

ALGORITMA MERGE SORT2.1 Konsep Algoritma Merge SortSecara konseptual, untuk sebuah array berukuran n,Merge Sort bekerja sebagai berikut:1. Jika bernilai 0 atau 1, maka array sudah terurut.Sebaliknya:2. Bagi array yang tidak terurut menjadi dua subarray,masing-masing berukuran n/2.3. Urutkan setiap sub-array. Jika sub-array tidakcukup kecil, lakukan rekursif langkah 2 terhadapsub-array.4. Menggabungkan dua sub-array kembali menjadisatu array yang terurut.Merge sort menggabungkan dua ide utama untukmeningkatkan runtimenya:1. Array kecil akan mengambil langkah-langkahuntuk menyortir lebih sedikit dari array besar.2. Lebih sedikit langkah yang diperlukan untukmembangun sebuah array terurut dari dua buaharray terurut daripada dari dua buah array takterurut.Dalam bentuk pseudocode, algoritma Merge Sort dapatterlihat seperti ini:procedure mergesort(input n : integer,input/output S : array[1..n] ofkeytype){Mengurutkan array sebesar n denganurutan takmenurunI.S. : n bilangan bulat positif, Sterdefinisi berindex dari 1 sampai nF.S. : array S berisi elemen denganurutan takmenurun}consth = n div 2m = n - hvarU : array [1..h] of keytypeV : array [1..m] of keytypebeginif n > 1 thencopy dari S[1] hingga S[h] ke Ucopy dari S[h+1] hingga S[n] ke Vmergesort(h,U)mergesort(m,V)merge(h,m,U,V,S)endend

2procedure merge(input h,m : integer, U: array [1..h] of keytype, V : array[1..m] of keytype, input/output S :array [1..h+m] of keytype){Menggabungkan dua array terurutmenjadi satu array terurutI.S. : h dan m bilangan bulat positif,array terurut U berindeks dari 1 sampaih, array terurut V berindeks dari 1sampai mF.S. : array S berindex dari 1 sampaih+m berisi elemen U dan V yang telahterurut}

vari,j,k : indeks;begini = 1j = 1k = 1while i<=h and j<=m doif U[i]<V[j] thenS[k]=U[i]i = i + 1elseS[k] = V[j]j = j+1k = k + 1endif i>h thencopy V[j] sampai V[m] ke S[k]sampai S[h+m]elsecopy V[i] sampai U[h] ke S[k]sampai S[h+m]endendGambar 1 : Langkah-langkah ketika mengurutkanmenggunakan Merge Sort

2.2. Kompleksitas Merge SortDalam algoritma ini, jumlah perbandingan yang terjadibergantung pada h dan m. Kondisi terburuk terjadi ketikaperulangan berhenti, karena salah satu indeks, sebut saja i,telah mencapai titik berhentinya dimana indeks lain j telahmencapai m – 1, lebih rendah 1 dari titik berhentinya.Sehingga,W(h,m) = h + m – 1Jumlah keseluruhan perbandingan adalah jumlahbanyaknya perbandingan dalam pemanggilan rekursifmerge sort dimana U sebagai input, banyaknyaperbandingan dalam pemanggilan rekursif merge sortdimana V sebagai input, dan banyaknya perbandingan ditop-level pemanggilan merge. Sehingga,W(n) = W(h) + W(m) + h + m – 1Pertama, kita menganalisa kasus diaman n adalaheksponen dari 2. Dalam kasus ini,Ekspresi untuk W(n) menjadiKetika besar input adalah 1, kondisi pemberhentianterpenuhi dan tak ada penggabungan. Sehingga, W(1)adalah 0.Waktu untukmengurutkan UWaktu untukmengurutkan VWaktu untukbergabung

3Solusi dari rekurens tersebut adalahMerge Sort akan selalu membagi dua tiap sub-arraynyahingga mencapai basis, sehingga kompleksitas darialgoritma Merge Sort, berlaku untuk semuakasus (Worst Case = Best Case = Average Case).

Merge Sort

Merge sort adalah salah satu metode sorting yang mirip dengan metode Quick sort, yaitu melakukan partisi. Algoritma merge sort membagi tabel/array menjadi dua tabel/array yang sama besar. Masing-masing tabel/array diurutkan secara rekursif, dan kemudian digabungkan kembali untuk membentuk tabel/array yang terurut. Implementasi dasar dari algoritma merge sort memakai tiga buah tabel/array, dua untuk menyimpan elemen dari tabel/array yang telah di bagi dua dan satu untuk menyimpan elemen yang telah terurut. Namun algoritma ini dapat juga dilakukan langsung pada dua tabel/array, sehingga menghemat ruang atau memori yang dibutuhkan.Berikut implemenatsi dalam bentuk gambar.

Algoritma Merge umumnya memiliki satu set pointer p0..n yang menunjuk suatu posisi di

dalam satu set daftar L0..n . Pada awalnya mereka menunjuk item yang pertama pada setiap

daftar. Algoritmanya sebagai berikut:

1. Melakukan sesuatu dengan data item yang menunjuk daftar mereka masing-masing.

2. Menemukan pointers points untuk item dengan kunci yang paling rendah; membantu salah

satu pointer untuk item yang berikutnya dalam daftar.

Contoh pengurutan dengan metode Merge sort.

Kasus: mengurutkan 50000 bilangan desimal yang diperoleh secara acak menggunakan

fungsi srand.

Source code Merge sort menggunakan bahasa C.

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h>#include <mcheck.h>

/* Fungsi untuk mengurutkan bilangan menggunakan metode Merge Sort */void mergeS(float *num, int p, int n){    int q = (p + n)/2;    if (p < n){ mergeS(num, p, q); mergeS(num, q + 1, n);

    int i = p;    int j = q + 1; int k = 0;    float *temp = (float*)malloc((n - p + 1) *sizeof(float));        while ((i <= q) && (j <= n)){    if (num[i] < num[j])     temp[k++] = num[i++];    else     temp[k++] = num[j++];    }     while (i <= q)    temp[k++] = num[i++];     while (j <= n)    temp[k++] = num[j++];

    memcpy(num + p, temp, (n - p + 1) *sizeof(int));    free(temp);    }}

/* Fungsi untuk mencetak bilangan yang sudah terurut */void printnum(float *num, int n){    int i;    for (i=0; i < n; ++i) printf("%5.2f \t", num[i]);    printf("\n");}

/* Fungsi utama */int main(void){    mtrace();    int i, n, opsi;    float num[50000];

    srand( time(NULL) ); /* inisialisasi random seed */

    /* Menampung jumlah bilangan yang diinputkan oleh user */    printf("\nMasukkan jumlah bilangan: ");    scanf("%d", &n);      /* Memberi statement jika jumlah bilangan yang diinputkan <= 0 */    if(n <= 0) printf("\nTidak ada data yang diacak.\n\n");

    /* Penelusuran dilanjutkan jika jumlah bilangan yang diinputkan > 0 */    else{ for(i=0; i<n; i++){    num[i] = rand() % 50000 + 1; /* Acak bilangan antara 0..50000 */    num[i] = num[i]/3; }

printf("\nAcak:\n"); /* Mencetak bilangan yang masih acak */ for(i=0; i<n; i++)    printf("%5.2f \t", num[i]);

    /* Menampilkan menu pilihan */    printf("\n\nRandom data dalam array selesai...\n\n");    printf("\nMenu Pilihan:");    printf("\n1) Mengurutkan data dengan MERGE SORT, dan menampilkannya.");    printf("\n2) Selesai.");          do{ /* Menampung menu pilihan yang diinput oleh user */    printf("\n\nPilihan Anda: ");    scanf("%d", &opsi);    switch(opsi){ /* Fungsi untuk mengganti menu pilihan */     case 1:     {    printf("\n# Pengurutan data dengan metode MERGE SORT #\n\n");    mergeS(num, 0, n-1);    printnum(num, n);     }break;       case 2:     {    printf("\nTerima kasih telah mengakses program ini ^_^\n\n");     }break;    }    }    while(opsi!=2);    }    return EXIT_SUCCESS;}

  KompleksitasPemecahan masalah dengan algoritma Divide and Conquer biasanya menghasilkan algoritma yangefisien, namun tentu saja waktu pencarian solusisangat bergantung dari jumlah masukan.Kompleksitas algoritma ini dapat dihitung dalamrelasi berikut :T(n) = g(n) , n < n02T(n/2) + f(n) , n > n0Keterangan :T(n) = waktu komputasi Divide and Conquer denganukuran masukan sebanyak ng(n) = waktu komputasi untuk penyelesaiansubproblemf(n) = waktu komputasi untuk menggabungkansolusi masing-masingsubproblemUntuk kasus rata-rata (average case), algoritma Divide and Conquer akan memiliki kompleksitasO(n log n)2.4 KeuntunganAlgoritma Divide and Conquer memiliki keuntungansebagai berikut :a. Dapat menyelesaikan persoalan sulitKebanyakan persoalan yang susah dipecahkan dapatdiselesaikan dengan algoritma ini, karena algoritmaini ‘hanya’ memerlukan pembagian masalah menjadimasalah yang lebih kecil, menyelesaikan masalah-masalah yang sudah dibagi tersebut, kemudianmenggabungkan solusi-solusi tadi menjadi solusidari persoalan awal.Walaupun demikian, tetap saja harus dipikirkan carayang tepat untuk membagi dan menggabungkanpersoalan, supaya dapat diselesaikan. Dan kadangkala algoritma ini adalah satu-satunya cara untuk menyelesaikan persoalan tersebut.b. Efisiensi algoritma Divide and Conquer biasanya memberikan desainalgoritma yang efisien. Contohnya, jika persoalantersebut dibagi, diselesaikan dan kemudiandigabungkan kembali, maka akan ada k sebagaifaktor pembagi, dan ada persoalan yang berukurann/k untuk tiap levelnya. Pencarian solusi untuk levelbasis memerlukan kompleksitas O(1), sehinggaalgoritma ini akan memiliki kompleksitas O(n log n).Hal ini diterapkan di beberapa persoalan, walaupunterkadang terdapat pendekatan-pendekatan laindalam pengimplementasiannya.c. Dapat berjalan secara paralelAlgoritma Divide and Conquer dapat dikerjakansecara paralel pada mesin multi-prosesor, karenapersoalan yang telah dibagi dapat dikerjakan secarabebas dan sama sekali tidak bergantung padapersoalan lainnya. Sangat menguntungkan apabilapersoalan yang dikerjakan berukuran besar, dapatdibagi untuk diselesaikan pada prosesor yangberbeda.2.5 KerugianKerugian utama pada Algoritma Divide and Conquer adalah sifat rekursifnya. Kebanyakanimplementasi dari algoritma ini memakai rekursi,sehingga terkadang menjadikannya lambat.Pemanggilan prosedur yang sama berkali-kali,mengakibatkan pemakaian memori untuk menyimpan urutan pemanggilan prosedur. Semakinbesar ukuran masukannya, akan dilakukan lebihbanyak lagi pemanggilan prosedur untuk membagimasukan tersebut, sehingga memperbanyak pemakaian memori.3. Heap Sort3.1 Penjelasan Singkat Heap So

rt adalah sebuah algoritma pengurutan yangpaling lambat dari algoritma yang memilikikompleksitas O(n log n). Tetapi tidak sepertialgoritma Merge Sort dan Quick Sort, algoritmaHeap Sort tidak memerlukan rekursif yang besaratau menggunakan banyak tabel (array). Oleh karenaitu, Heap Sort adalah pilihan yang baik untuk sebuahkumpulan data yang besar.Algoritma ini dimulai dengan membangun sebuaharray  heapdengan membangun tumpukan darikumpulan data, lalu memindahkan data terbesar kebagian belakang dari sebuah tabel hasil. Setelah itu,array  heapdibangun kembali, kemudian mengambilelemen terbesar untuk diletakkan di sebelah itemyang telah dipindahkan tadi. Hal ini diulang sampaiarray heaphabis.Jadi secara umum, algoritma ini memerlukan duabuah tabel; satu tabel untuk menyimpanheap, dansatu tabel lainnya untuk menyimpan hasil. Walaupunlebih lambat dari Merge Sort atau Quick Sort,algoritma ini cocok untuk digunakan pada data yangberukuran besar.3.2 Algoritma Heap Sort3.2.1 Pseudo-codefunctionheapSort(a, count) {var intstart := count ÷ 2 - 1,end := count - 1whilestart≥0sift(a, start, count)start := start - 1whileend > 0swap(a[end], a[0])sift(a, 0, end)end := end - 1}2

  functionsift(a, start, count) {var introot := start, childwhileroot * 2 + 1 < count {child := root * 2 + 1ifchild < count - 1anda[child] < a[child + 1]child := child + 1if

a[root] < a[child]swap(a[root], a[child])root := childelse return }}Keterangan :swap : prosedur yang telah didefiniskan, untuk menukar isi dari argumen 1 dengan argumen 2.3.2.2 Contoh implementasivoidheapSort(intnumbers[],intarray_size){inti, temp;for(i = (array_size / 2)-1; i >= 0; i--)siftDown(numbers, i, array_size);for(i = array_size-1; i >= 1; i--){temp = numbers[0];numbers[0] = numbers[i];numbers[i] = temp;siftDown(numbers, 0, i-1);}}voidsiftDown(intnumbers[],introot,int bottom){intdone, maxChild, temp;done = 0;while((root*2 <= bottom) && (!done)){if(root*2 == bottom)maxChild = root * 2;else if(numbers[root * 2] >numbers[root * 2 + 1])maxChild = root * 2;else maxChild = root * 2 + 1;if(numbers[root] < numbers[maxChild]){temp = numbers[root];numbers[root] = numbers[maxChild];numbers[maxChild] = temp;root = maxChild;}else done = 1;}}3.3 Contoh kasus3.3.1 Kasus terbaik ( Best case)Jika masukan yang diberikan dalam Heap Sortadalah berurutan mengecil, maka akan diperolehkasus terbaik untuk algoritma ini. Karena dalampembuatan pohonheap

-nya hanya memerlukansekali passsaja, dan tidak dilakukan pertukaranelemen. Pertukaran hanya dilakukan pada saat sudahtercapai pohonheapyang akarnya berelementerbesar, untuk menaruhnya pada tabel hasil.Berikut adalah contoh gambar algoritma Heap Sortdengan masukan : 1 2 33.3.2 Kasus terburuk (Worst case)3

  Sedangkan kasus terburuk terdapat pada masukanyang telah berurut membesar. Hal ini diakibatkankarena pertukaran elemen yang terjadi merupakanyang terbanyak dari kasus lainnya, dimana elementerbesar yang seharusnya berada di akar, terdapat dianak pohon yang paling dalam.Berikut adalah contoh gambar dari algoritma HeapSort dengan masukan : 1 2 33.3.3 Kasus acak ( Random case)Kasus acak mempunyai urutan masukan yang tidak terdapat pada dua kasus di atas, yaitu tidak diketahuidi mana letak elemen terbesar yang akan menjadielemen akar.Berikut adalah contoh algoritma Heap Sort denganmasukan : 2 1 34

   4. KesimpulanMeskipun lebih lambat dari algoritma pengurutandata yang lain, algoritmaheap sort memilikikelebihan ketika menangani data dalam skala yangbesar/ massive. Karena algoritma ini memilikikelebihan tidak menggunakan banyak tabel, tetapihanya satu tabel yang dipakai untuk menyimpanhasil dari pengurutan tersebut.5. Daftar Pustaka[1] Heap sort visualization Java applet.  http://www2.hawaii.edu/~copley/665/HSAp   plet.html   . Diakses tanggal 18 Mei 2006pukul 22.00 WIB [2] Heapsort - Wikipedia, the free encyclopedia.  http://en.wikipedia.org/wiki/Heap_sort . Diakses tanggal 18 Mei 2006 pukul 21.00WIB[3] Munir M. T., Rinaldi. 2005.“Diktat Kuliah IF2251, Strategi Algoritmik”. Bandung :Institut Teknologi Bandung.[4] Three Divide and Conquer SortingAlgorithms.  http://www.ics.uci.edu/~eppstein/161/96011 8.html   . Diakses tanggal 18 Mei 2006 10.00WIB5