L A P O R A N

DESAIN DAN ANALISA

ALGORITMA

Algoritma Pencarian

Quick Sort

Oleh :

1210652030

Hendra Dwi Saputra

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS TEKNIK

UNIVERSITAS MUHAMMADIYAH JEMBER

2 0 1 4

A. PENJELASAN ALGORITMA

Quicksort adalah algoritma pengurutan cepat yang tidak hanya digunakan

dalam dunia pendidikan, tetapi banyak diterapkan secara prkaktik. Rata-rata,

biasanya memiliki kompleksitas O(n log n), membuat quicksort sangat cocok untuk

mengurutkan volume data yang besar. Ide dari algoritma ini cukup sederhana dan

ketika kita menyadarinya, kita dapat menulis quicksort secepat bubblesort.

Strategi divide-and-conqueror digunakan di dalam quicksort. Di bawah ini

akan dijelaskan langkah-langkahnya :

1. Pilih nilai pivot. Kita ambil nilai di tengah-tengah elemen sebagai sebagai nilai

dari pivot, tetapi bisa nilai mana saja.

2. Partisi. Atur ulang semua elemen sedemikian rupa, lalu semua elemen yang lebih

rendah daripada pivot dipindahkan ke sebelah kiri dari array/list dan semua

elemen yang lebih besar dari pivot dipindahkan ke sebelah kanan dari array/list.

Nilai yang sama dengan pivot dapat diletakkan di mana saja dari array. Ingat,

mungkin array/list akan dibagi dalam bagian yang tidak sama.

3. Urutkan semua bagian (kiri/kanan). Aplikasikan algoritma quicksort secara

rekursif pada bagian sebelah kiri dan kanan.

Algoritma Partisi secara detail.

Ada dua indeks i dan j dan pada awal algoritma partisi i menunjuk ke elemen

pertama dalam array dan poin j yang terakhir. Kemudian algoritma menggerakkan i

ke depan, sampai elemen dengan nilai yang lebih besar atau sama dengan pivot

ditemukan. Indeks j bergerak mundur, sampai elemen dengan nilai yang lebih rendah

atau sama dengan pivot ditemukan. Jika i ≤ j maka mereka bertukar dan saya

langkah ke posisi berikutnya (i + 1), langkah-langkah j dengan yang sebelumnya (j -

1). Algoritma berhenti, ketika saya menjadi lebih besar dari j. Setelah partisi, semua

nilai sebelum elemen ke-i kurang atau sama dengan pivot dan semua nilai setelah

elemen ke-j lebih besar atau sama dengan pivot.

B. PILIHAN ALGORITMA DAN BAHASA

i. Algoritma QuickSort

Saya memilih algoritma ini, dikarenakan saya baca di beberapa referensi

algoritma ini memiliki kecepatan dibandingkan dengan algoritma pengurutan

yang lain. Saya lihat pseucode dan keterangannya juga cukup mudah dimengerti.

Dan yang paling penting adalah banyak sekali contoh kode dan penjelasannya di

internet, untuk berbagai macam bahasa pemrograman.

Kelebihan

Algoritma Quicksort memiliki kompleksitas O(n log n) dimana pada

prakteknya lebih cepat dari algoritma pengurutan lainnya. (Sumber :

wikipedia)

Kekurangan

Pada kemungkinan terburuknya, algoritma Quicksort ini dapat memiliki

kompleksitas O(n2). Meskipun ini sangat langka terjadi.

ii. Bahasa Pemrograman (C++ Qt Framework)

Bahasa pemrograman C++ adalah pengembangan dari bahasa C yang telah

banyak dan luas penggunaannya khususnya di bidang sistem operasi yang

menggunakan bahasa ini (hampir semua sistem operasi). Dan saya tambahkan

pusataka Qt Framework untuk lebih mudah menangani list menggunakan QList.

Kelebihan

Karena merupakan bahasa tingkat menengah yang dikompilasi menjadi bahasa

biner atau bahasa mesin, maka eksekusi oleh komputer akan menjadi lebih

cepat dan mempunyai manajemen memori yang lebih baik.

Kekurangan

Sintaks yang cukup rumit khususnya bagi pengembang baru jika dibandingkan

dengan Python yang memiliki kesedarhanaan dalam penulisan sintaksnya

yang memiliki garbage collector.

C. LINGKUNGAN KERJA

Percobaan ini dilakukan pada Netbook AMD LENOVO THINKPAD E135,

dengan spesifikasi perangkat sebagai berikut :

- Processor AMD E2-2000 APU with Radeon(tm) Graphics 1.75 GHz

- Memori RAM 6 GB

- Harddisk 500 GB

- Windows 8.1 Pro

- Qt Creator 3.3.0

- Qt 5.4.0

- MinGW Compiler 4.9.1 32bit

D. IMPLEMENTASI

Pseudo-code

Program

#include <QCoreApplication>

#include <QFile>

#include <QList>

#include <QString>

#include <QTime>

#include <QDebug>

QTime waktu;

QList<int> data;

void bukaBerkas()

{

QFile berkas("D://randomNumbers.txt");

if (!berkas.open(QFile::ReadOnly | QFile::Text))

{

qDebug() << "Tidak dapat membuka berkas untuk dibaca";

return;

}

QTextStream baca(&berkas);

QString konten = baca.readAll();

QList<QString> temp = konten.split("\t");

for (int i = 0; i < temp.length(); i++)

{

data.append(temp[i].toInt());

}

qDebug() << "Berkas dibaca sebanyak" << data.length() <<

"data";

berkas.close();

}

void simpanBerkas()

{

QFile berkas("D://sortNumber.txt");

if (!berkas.open(QFile::WriteOnly | QFile::Text))

{

qDebug() << "Tidak dapat membuka berkas untuk ditulis";

return;

}

QStringList temp;

for (int i = 0; i < data.length(); i++)

{

temp.append(QString::number(data[i]));

}

QTextStream simpan(&berkas);

QString konten = temp.join("\t");

simpan << konten;

qDebug() << "Data telah disimpan.";

berkas.flush();

berkas.close();

}

void quickSort(int kiri, int kanan) {

int i = kiri, j = kanan;

int kunci;

int pivot = data[(kiri + kanan) / 2];

/* Partisi */

while (i <= j) {

while (data[i] < pivot)

i++;

while (data[j] > pivot)

j--;

if (i <= j) {

kunci = data[i];

data[i] = data[j];

data[j] = kunci;

i++;

j--;

}

};

/* Rekursi */

if (kiri < j)

quickSort(kiri, j);

if (i < kanan)

quickSort(i, kanan);

}

int main(int argc, char *argv[])

{

QCoreApplication app(argc, argv);

/* Membaca Berkas */

bukaBerkas();

/* Quick Sort */

waktu.start();

quickSort(0, data.length()-1);

qDebug() << "Menjalankan Quick Sort...";

qDebug() << "Waktu yang dibutuhkan" << waktu.elapsed() <<

"milidetik";

/* Menyimpan Berkas */

simpanBerkas();

return app.exec();

}

Saya membuat program ini dengan beberapa fungsi yang pertama adalah

untuk membuka file dan menyimpannya ke dalam sebuah list/array dengan fungsi

bukaBerkas() yang dapat dilihat pada kode di atas. List/array tersebut saya jadikan

sebuah variabel global yang dapat diakses oleh fungsi mana saja sehingga tidak perlu

memuat banyak memori hanya untuk list agar lebih cepat. Kemudian List yang telah

diisi oleh data, diurutkan dengan fungsi quickSort() yang telah dibuat sebelumnya.

Di dalam fungsi quickSort() ini telah dibuat juga fungsi partisi yang dijadikan satu.

Tidak lupa juga ada fungsi untuk menghitung waktu yang diperlukan dalam

melakukan pengurutan dengan quickSort() menggunakan fungsi dari pustaka QTime.

Kemudian hasil list/array yang telah diurutkan disimpan ke dalam berkas (file) yang

dapat dilihat apakah sudah urut atau tidak.

Untuk fungsi quickSort() dapat dijelaskan sebagai berikut :

int i = kiri, j = kanan;

int kunci;

int pivot = data[(kiri + kanan) / 2];

Membuat variabel yang dibutuhkan, yaitu i untuk bagian kiri dan j untuk bagian

kanan. Dan variabel kunci digunakan untuk perpindahan atau pertukaran nilai yang

dipindah dari fungsi partisi. Variabel pivot adalah nilai indeks tengah dimana

didapatkan dengan cara indeks kiri ditambah indeks kanan dibagi 2 (dua).

/* Partisi */

while (i <= j) {

while (data[i] < pivot)

i++;

while (data[j] > pivot)

j--;

if (i <= j) {

kunci = data[i];

data[i] = data[j];

data[j] = kunci;

i++;

j--;

}

};

Selama indeks i kurang dari sama dengan indeks j, selama array/list data pada indeks

i kurang dari pivot maka indeks i di-increment. Selama array/list data pada indeks j

lebih besar pivot maka indeks j di-decrement. Jika i kurang dari sama dengan j

lakukan kunci sama dengan array/list data pada indeks i, lakukan array/list pada

indeks i sama dengan array/list data pada indeks j, lakukan array/list pada indeks j

sama dengan kunci, kemudian increment indeks i dan decrement indeks j.

/* Rekursi */

if (kiri < j)

quickSort(kiri, j);

if (i < kanan)

quickSort(i, kanan);

Terakhir jika indeks kiri kurang dari indeks j lakukan fungsi quicksor(kiri, j) dan jika

indeks i kurang dari kanan lakukan fungsi quicksort(i, kanan).

E. SCREENSHOT

Penulisan program dengan QtCreator

Hasil menjalankan

Berkas randomNumbers.txt

Berkas sortNumber.txt

F. HASIL DAN KECEPATAN

Kecepatan

Setelah dijalankan program sebanyak 10 kali dengan algoritma quicksort ini,

maka dihasilkan kecepatan yang tersaji dalam tabel di bawah ini :

PERCOBAAN WAKTU

(milidetik)

Pertama 4.782

Kedua 4.327

Ketiga 4.360

Keempat 4.295

Kelima 4.345

Keenam 4.469

Ketujuh 4.397

Kedelapan 4.457

Kesembilan 4.443

Kesepuluh 4.416

Kesimpulan

Menurut saya, mengurutkan 1.000.000 data dalam waktu sekitar 4 detik

saja adalah sangat cepat. Tetapi tentunya masih perlu dibandingkan

dengan algoritma pengurutan yang lain. Kondisinya pengujiannya juga

perlu diuji dengan tanpa beban sistem operasi yang terlalu berat dan juga

sampel yang berbeda pula. Mungkin juga diaplikasikan dimana tidak

hanya mengurutkan angka tetapi mungkin juga string. Bisa juga

dikembangkan dengan menggunakan teknik komputasi paralel sehingga

bisa lebih cepat lagi ketika dijalankan pada komputer yang memiliki

processor multi core ataupun komputer dengan multi processor.

Program ini tentunya masih sangat kurang sempurna sekali, karena

seharusnya harus bisa memasukkan sampel menggunakan antarmuka

GUI. Mungkin di lain waktu bisa dibuat ;-). Terima Kasih.