Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

(1)

// C++ program for generated data

static const char alphanum[] =

"0123456789""abcdefghijklmnopqrstuvwxyz"; int stringLength = sizeof(alphanum) - 1; char genRandom()

{

return alphanum[rand() % stringLength]; }

for(unsigned long i = 0; i<600; ++i)// generate data {

Str += genRandom(); }

out_stream.open("data.txt");

for (int i=0; i<600; i++)// memanggil data yg digenerate tersebut {

out_stream << Str[i];

if(i % 6==5) out_stream<<endl; }

double stop=clock(); out_stream.close();

cout<<setiosflags(ios::fixed); cout<<setprecision(6);

cout<<"Waktu eksekusi program: " <<(stop-start); cout<<" milidetik ";

(2)

// C++ program for quicksort

void quick_sort(string arr[], int left, int right) {

int i = left, j = right;

string tmp; string pivot = arr[(left+right)/2];/* partition */ while (i<j)

{

while (arr[i] < pivot) i++;

while (arr[j] > pivot) j--;

void qs(char *items, int left, int right) {

while((items[i] < x) && (i < right)) i++;

(3)

while(i <= j);

while(!ambil.eof()) //ambil data ke array {

for(vector<string>::iterator it = data.begin() ; it != data.end(); ++it)

{

dataa[n] = *it; n++;

}

for (unsigned long i=0;i<n-1;i++) {

out_stream << dataa[i] << endl; }

quick_sort(dataa,0,n-2);

double stop=clock(); // running time out_stream.close();

(4)

// C++ program for 3-way quicksort

(5)

void quicksort(string a[], int l, int r)

while(!ambil.eof()) //ambil data ke array {

{

a[n] = *it; n++;

}

int size = sizeof(a) / sizeof(int); for (unsigned long i=1;i<n;i++) {

out_stream << a[i] << endl; }

quicksort(a,0,size-1);

(6)

// C++ program for radixsort

void print(string kata, int n) {

int i;

for (i = 0; i < n; i++) cout<<"%c\t", kata[i]; }

string radixsort(string kata, int n) {

bucket[kata[i] / exp % 10]++; for (i = 1; i < 10; i++) bucket[i] += bucket[i - 1]; for (i = n - 1; i >= 0; i--)

(7)

ambil.close();

string dataa[data.size()];

{

dataa[i] = *it; i++;

}

for (unsigned long j=0;j<i;j++) {

out_stream << dataa[j] << endl; }

(8)

DATA PRIBADI

Nama Lengkap : Ploren Peronica Pasaribu

Tempat dan Tanggal Lahir : Medan, 28 Februari 1993

Alamat Rumah : Jl. Jermal 7 Komplek Fadillah No. 8 Medan

Jenis Kelamin : Perempuan

Agama : Kristen Protestan

Status : Belum kawin

No. Telepon Rumah/HP : 085372214628

E-mail : peronica.pasbond@gmail.com

RIWAYAT PENDIDIKAN FORMAL

1998–2004 : SD NEGERI 104237 TANJUNG MORAWA

2004–2007 : SMP NEGERI 1 TANJUNG MORAWA

2007–2010 : SMA NEGERI 1 LUBUKPAKAM

2010–2013 : D3 Teknik Informatika Universitas Sumatera Utara

SEMINAR

Peserta Seminar Nasional Literasi Informasi 2014 Universitas Sumatera Utara

PENGALAMAN KERJA

2012 : Magang di PT. PLN (Persero) WILAYAH SUMUT

AREA Medan

(9)

[1] _{Aulia, Rahma. 2006. Analisis Kecepatan Sorting dengan Notasi Big O. Bandung:}

Program Studi Teknik Informatika, Institut Teknologi Bandung.

[2] _{Cormen, Thomas. H et al. 2009. Introduction to Algorithms Third Edition. London:}

MIT Press.

[3] _{DF Alfatwa, ER Syah P, FM Ahsan. 2005.Implementasi Algoritma Radix Sort}

dalam Berbagai Kasus Bilangan Dibandingkan Algoritma Pengurutan yang

lain. Bandung: Program Studi Teknik Informatika, Institut Teknologi Bandung.

[4] _{Indrayana, Ihsan, M., Fauzi. 2005. Perbandingan Kecepatan/Waktu Komputasi}

Beberapa Algoritma Pengurutan (Sorting). Bandung: Program Studi Teknik

Informatika, Institut Teknologi Bandung.

[5] _{Kadir, M. 2013. Teori dan Aplikasi Struktur Data Menggunakan C++. Andi:}

Yogyakarta.

[6] _{Kristanto, Andri. 2003. Algoritma dan Pemrograman dengan C++. Graha Ilmu:}

Yoyakarta.

[7] _{Munir, R. 2004. Diktat Kuliah IF3051 Strategi Algoritma. Bandung: Program}

Studi Teknik Informatika, Institut Teknologi Bandung.

[8] _{Rahman, A. 2005. Analisis Algoritma Radix Sort. Bandung: Program Studi Teknik}

Informatika, Institut Teknologi Bandung.

[9] _{Sedgewick, R., Wayne, K., 2011. Algorithms Fourth Edition. Boston: Princeton}

University.

(10)

[12] _{Tjaru, Setia N.B. 2010. Kompleksitas Algoritma Pengurutan Selection Sort dan}

Insertion Sort. Bandung: Program Studi Teknik Informatika, Institut Teknologi

(11)

3.1. Analisis Masalah

Masalah yang diangkat dalam penelitian ini adalah bagaimana menganalisis

kompleksitas waktu menggunakan algoritma QuickSort, 3 Way QuickSort, dan

RadixSort.

Gambar 3.1 merupakan Diagram Ishikawa (Fish Bone) yang digunakan untuk

mengidentifikasi semua penyebab yang berhubungan dengan suatu permasalahan.

Terdapat 3 bagian penting dalam Diagram Ishikawa:

1. Bagian kepala berfungsi sebagai akibat (effect), yaitu masalah yang ingin

dianalisis.

2. Bagian tulang berfungsi sebagai penyebab utama (main cause), yaitu faktor-faktor

penyebab terjadinya masalah.

3. Bagian panah pada tulang berfungsi sebagai pernyataan sekunder dari penyebab

utama.

lebih kompleks pengurutan yang

dalam pengurutan terlalu lama

unik

(12)

3.2. Analisis Kebutuhan Sistem

Untuk membangun sebuah sistem, perlu dilakukan sebuah tahap analisis kebutuhan

sistem. Analisis kebutuhan sistem dapat dikelompokkan menjadi 2 bagian yaitu

kebutuhan fungsional dan kebutuhan non-fungsional yang menjelaskan fitur-fitur,

karakteristik dan batasan lainnya (optional).

3.2.1. Kebutuhan fungsional

Kebutuhan fungsional merupakan deskripsi dari aktivitas dan layanan yang sistem

harus berikan. Hal yang menjadi kebutuhan fungsional dalam pengurutan data acak ini

adalah:

1. Sistem harus mampu mengurutkan data acak berupa string dengan 6 karakter

2. Sistem mampu menghitung running time dan menganalisis kompleksitas

waktu algoritma pengurutan berdasarkan algoritma QuickSort, algoritma 3

Way QuickSort, dan algoritma RadixSort.

3.2.2. Kebutuhan non-fungsional

Kebutuhan non-fungsional merupakan deskripsi dari beberapa fitur, karateristik, dan

batasan suatu sistem. Kebutuhan non-fungsional dari sistem adalah:

1. Mudah Digunakan (User Friendly)

Sistem yang akan dibangun harus user friendly, artinya bahwa sistem mudah

digunakan dan dipahami oleh user

2. Menjadi Referensi

Sistem yang akan dibangun diharapkan mampu menjadi referensi bagi user

untuk menganalisis kompleksitas waktu pengurutan data acak.

3. Pelayanan

Sistem yang telah dirancang bisa dikembangkan ke tingkat yang lebih

kompleks lagi bagi pihak-pihak yang ingin mengembangkan sistem tersebut

(13)

3.3. Analisis Proses

Dalam sistem ini terdapat dua proses utama, antara lain: proses pengurutan dan

kompleksitas waktu berdasarkan algoritma QuickSort, algoritma 3 Way QuickSort,

dan algoritma RadixSort. Pengurutan dimulai dari karakter pertama pada setiap string

(Gambar 3.2) dan karakter berdasarkan tabel ASCII kode desimal (Gambar 3.3)

Gambar 3.2 Data Acak Data.txt-Notepad

sctzmk m52zq7 tuwova ul31qu r4rf8j rstau0 19q7aj pblau3 z6rd9n n23cnn

(14)

(15)

3.4. Pemodelan Sistem

Pemodelan sistem yang dirancang bertujuan menggambarkan peran user terhadap

sistem yang dibuat. Pemodelan sistem yang digunakan dalam perancangan sistem,

yaitu use-case diagram, activity diagram, dan sequence diagram.

3.4.1. Use-case diagram

Diagram ini memperlihatkan himpunan use-case dan aktor-aktor (suatu jenis khusus

dari kelas). Diagram ini terutama sangat penting untuk mengorganisasi dan

memodelkan perilaku dari suatu sistem yang dibutuhkan serta diharapkan pengguna.

Berikut disajikan penjelasan mengenai peristiwa proses pengurutan algoritma sorting

dalam use case diagram.

Gambar 3.4 Use Case Diagram Sistem

user

Pembangkitan Data Acak Data Acak.txt

Pengurutan Data Algoritma QuickSort

Pengurutan Data Algoritma 3 Way QuickSort

Pengurutan Data Algoritma RadixSort

(16)

3.4.2. Activity diagram

Activity diagram menggambarkan berbagai alir aktivitas dalam sistem yang sedang

dirancang, bagaimana masing-masing alir berawal, decision yang mungkin terjadi, dan

bagaimana berakhir. Pada Gambar 3.3 menjelaskan rancangan aktivitas user dan

respon sistem pada aplikasi.

Gambar 3.5 Activity Diagram Sistem

User Sistem

Pembangkitan Data Menghitung running time

Pengurutan berdasarkan Algoritma Quicksort Menghitung running time

Menghitung running time Pengurutan berdasarkan Algoritma 3 Way QuickSort

Pengurutan berdasarkan Algoritma RadixSort Menghitung running time

(17)

Berdasarkan Activity Diagram tersebut maka rancangan aktifitas sistem dapat

dijelaskan pada Tabel 3.1.

Tabel 3.1 Activity Diagram Sistem Name Activity

Diagram

Activity Diagram System

Actor User (Pengguna)

Deskripsi Diagram Activity tersebut menjelaskan rancangan aktifitas user dan

respon sistem

Prakondisi Dimulai dengan generated data

Aktifitas dan

Respon

Aktifitas User Respon Sistem

1. Run and debug program

generated data

pengurutan Algoritma

QuickSort

pengurutan Algoritma 3

Way QuickSort

pengurutan Algoritma

RadixSort

1. Sistem menampilkan running

time proses generated data

tersebut

time Algoritma QuickSort

tersebut

time Algoritma 3 Way

QuickSort tersebut

time Algoritma RadixSort

tersebut

Pasca Kondisi Menampilkan hasil pengurutan ketiga algoritma sorting dalam

(18)

3.4.3. Sequence diagram

Sequence diagram (diagram urutan) adalah suatu diagram yang memperlihatkan atau

menampilkan interaksi-interaksi antar objek di dalam sistem yang disusun pada

sebuah urutan atau rangkaian waktu. Interaksi antar objek tersebut termasuk

pengguna, display, dan sebagainya berupa message (pesan). Pada Gambar 3.6

menggambarkan perilaku user terhadap sistem.

Gambar 3.6 Sequence Diagram Sistem

3.5. Flowchart Sistem

Flowchart adalah sebuah diagram umum yang mempresentasikan sebuah algoritma

atau proses menggunakan beberapa bangun geometri untuk memperlihatkan

langkah-langkah yang dilakukan oleh program dalam menyelesaikan masalah[11].

User Data Acak (.txt) _{Algoritma QuickSort} _{Algoritma 3 Way QuickSort} _{Algoritma RadixSort}

1 : generated data()

2 : data acak() 3 : pengurutan data()

4 : data terurut()

5 : pengurutan data()

6 : data terurut()

7 : pengurutan data()

(19)

3.5.1. Flowchart algoritma QuickSort

Flowchart algoritma QuickSort dapat kita lihat pada Gambar 3.7 di bawah ini.

(20)

3.5.2. Flowchart algoritma 3 Way QuickSort

Flowchart algoritma 3 Way QuickSort dapat kita lihat pada Gambar 3.8 di bawah ini.

(21)

3.5.3. Flowchart algoritma RadixSort

Flowchart algoritma RadixSort dapat kita lihat pada Gambar 3.9 di bawah ini.

Start

n data bilangan

Pengkategorian dari digit terkanan (r)

Konkatenasi

Data terurut

Stop r=[r]-1

Yes No

(22)

4.1. Implementasi Sistem

Pada tahap implementasi sistem ini akan dibahas bagaimana penerapan dari analisis

dan perancangan sistem yang telah dilakukan dan dipaparkan pada bab sebelumnya,

membahas bagaimana jalannya aplikasi dalam laptop dengan spesifikasi Intel Pentium

P6300, RAM 3GB, HDD 320 GB, dan juga perhitungan analisis setiap algoritma .

4.2. Generated Data

Generated data merupakan proses untuk membangkitkan data acak. Dalam hal ini,

kita ambil contoh dengan n = 100 strings. Dalam proses compile (Gambar 4.1), akan

terlihat berapa lama proses yang dibutuhkan untuk mengeksekusi data tersebut. Hasil

generated data (.txt) juga dapat dilihat pada Gambar 4.2

(23)

(24)

4.3. Algoritma QuickSort

Dalam tahapan ini, compiler melakukan pengurutan secara QuickSort berdasarkan

jumlah data yang telah dibangkitkan. Dalam hal ini, kita ambil contoh dengan n = 100

strings. Dalam proses compile (Gambar 4.3), akan terlihat berapa lama proses yang

dibutuhkan untuk mengeksekusi data tersebut. Hasil pengurutan berdasarkan

algoritma QuickSort (.txt) juga dapat dilihat pada Gambar 4.4.

(25)

(26)

4.3.1. Analisis algoritma Quicksort

Tahapan dalam melakukan partisi pada Algoritma QuickSort sebagai berikut:

1. Pilih x Є {A1, A2, ... , An} sebagai elemen pivot (x)

2. Lakukan scanning tabel dari kiri ke kanan sampai ditemukan Ap≥x 3. Lakukan scanning tabel dari kanan ke kiri sampai ditemukan Aq≤x 4. Swap Ap↔ Aq

5. Ulangi langkah ke-2, sampai kedua scanning bertemu di tengah tabel.

Berdasarkan Tabel ASCII. Maka:

s=115

2. Melakukan scanning tabel dari kiri ke kanan sampai ditemukan Ap≥x dan scanning tabel dari kanan ke kiri sampai ditemukan Aq≤x

115 109 116 117 114 114 049 112 122 110

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

115 109 116 117 114 114 049 112 122 110

x

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

115 109 116 117 114 114 049 112 122 110

(27)

3. Swap Ap↔ Aq

4. Mengulangi langkah ke-2 dari posisi p+1 dan dari posisi q-1, sampai kedua

scanning bertemu ditengah tabel.

5. Swap Ap↔ Aq

7. Swap Ap↔ Aq

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

110 109 116 117 114 114 049 112 122 115

P x q

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

110 109 116 117 114 114 049 112 122 115

p x q

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

110 109 112 117 114 114 049 116 122 115

p x q

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

110 109 112 117 114 114 049 116 122 115

P x q

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

110 109 112 049 114 114 117 116 122 115

(28)

9. Proses berhenti dan bagi partisi menjadi 2 tabel, karena p≤q di tengah tabel

Hasil partisi pertama:

A1 A2 A3 A4 A5

110 109 112 049 114

10. Menentukan pivot

A1 A2 A3 A4 A5

110 109 112 049 114

x

11. Melakukan scanning tabel dari kiri ke kanan sampai ditemukan Ap≥x dan

scanning tabel dari kanan ke kiri sampai ditemukan Aq≤x

A1 A2 A3 A4 A5

110 109 112 049 114

x

p

q

12. Swap Ap↔ Aq

A1 A2 A3 A4 A5

110 109 049 112 114

x

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

110 109 112 049 114 114 117 116 122 115

p x

(29)

13. Mengulangi scanning, karena pivot telah berubah

A1 A2 A3 A4 A5

110 109 049 112 114

p x

q

14. Swap Ap↔ Aq

A1 A2 A3 A4 A5

049 109 110 112 114

x

15. Mengulangi scanning, karena pivot telah berubah. Namun, karena tidak

ditemukan syarat Ap≥xdan Aq≤x. Maka, proses partisi pertama selesai.

A1 A2 A3 A4 A5

049 109 110 112 114

Hasil partisi kedua:

A6 A7 A8 A9 A10

114 117 116 122 115

A6 A7 A8 A9 A10

114 117 116 122 115

x

A6 A7 A8 A9 A10

114 117 116 122 115

(30)

18. Swap Ap↔ Aq

A6 A7 A8 A9 A10

114 115 116 122 117

P x q

19. Mengulangi scanning hingga bertemu di tengah tabel

A6 A7 A8 A9 A10

114 115 116 122 117

x

p

q

20. Proses berhenti dan bagi partisi menjadi 2 tabel, karena p≤q di tengah tabel

Hasil partisi kedua bagian pertama:

A6 A7 A8

Hasil partisi kedua bagian kedua:

A9 A10

(31)

A9 A10

122 117

x

A9 A10

26. Mengulangi scanning, karena pivot telah berubah. Namun, karena tidak

ditemukan syarat Ap≥x dan Aq≤x. Maka, proses partisi kedua bagian kedua

selesai.

A9 A10

117 122

27. Hasil akhir keseluruhan proses partisi

A1 A2 A3 A4 A5

049 109 110 112 114

A6 A7 A8

114 115 116

(32)

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

049 109 110 112 114 114 115 116 117 122

1 m n p r r s t u Z

Namun, proses belum berhenti karena ditemukan 2 angka yang sama (huruf s dalam

tabel ASCII). Untuk mengetahui urutan mana yang terlebih dahulu, maka pengurutan

dilanjutkan pada karakter kedua pada kedua string tersebut (r4rf8j dan rstau0).

4=052

s=115

052 115

A5 A6

052 115

x

29. Karena tidak ditemukan syarat Ap≥xdan Aq≤x. Maka, proses selesai.

A5 A6

052 115

30. Hasil akhir untuk pengurutan karakter kedua pada kedua string tersebut (r4rf8j

dan rstau0)

A5 A6

052 115

(33)

31. Maka hasil pengurutan 10 string tersebut dapat dilihat pada Gambar 4.5.

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

049 109 110 112 114 114 115 116 117 122

1 m n p r r s t u z

Gambar 4.5 Hasil Pengurutan Algoritma QuickSort

A5 A6

052 115

(34)

4.3.2. Analisis kompleksitas waktu (Tn) dan grafik perbandingan algoritma

QuickSort

Berikut dipaparkan analisis kompleksitas waktu T(n) dan running time (Tabel 4.1) dan

grafik running time algoritma QuickSort (Gambar 4.6)

hdc

115 109 116 117 114 114 049 112 122 110

109 049 112 110 115 116 117 114 122

109 049 112 110 114 114 116 117 122

049 ₁₁₂ ₁₁₀ ₁₁₄ ₁₁₄ ₁₁₅ ₁₁₆ ₁₁₇ ₁₂₂

049 109 110 112 114 114 115 116 117 122 109

H 114

(35)

T(n) = w. H

= n.2log n + 2

= n log n + 2n

= θ( n log n)

Tabel 4.1 Running Time Perbandingan Algoritma QuickSort a. Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB

n QuickSort (satuan waktu milidetik)

60 1

600 3

6000 16

60000 58

b. Intel Pentium P6300, RAM 3GB, HDD 320 GB

Gambar di bawah ini menunjukkan grafik perbandingan algoritma QuickSort

a. Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB n QuickSort (satuan waktu milidetik)

60 0

600 3

6000 31

(36)

Gambar 4.6 Grafik Running Time Perbandingan Algoritma QuickSort

4.4. Algoritma 3 Way QuickSort

Dalam tahapan ini, compiler melakukan pengurutan secara 3 Way QuickSort

berdasarkan jumlah data yang telah dibangkitkan. Dalam hal ini, kita ambil contoh

dengan n = 100 strings. Dalam proses compile (Gambar 4.7), akan terlihat berapa lama

proses yang dibutuhkan untuk mengeksekusi data tersebut. Hasil pengurutan

(37)

(38)

4.4.1. Analisis algoritma 3 Way Quicksort

Mekanisme pengurutannya adalah sebagai berikut:

1. Pilih x1, x2, x3Є {A1, A2, ... , An} sebagai elemen pivot (x1, x2, x3) 2. Susun pivot dengan syarat x1 > x2 > x3

3. Atur semua data selain pivot (x1, x2, x3) sesuai urutan kemunculan dengan

syarat data yang lebih kecil dari pivot (x1, x2, x3) berada di sebelah kiri pivot

dan data yang lebih besar atau sama dengan pivot berada di sebelah kanan

pivot.

4. Ulangi langkah pertama hingga keseluruhan data terurut (A1<A2<A3...<An)

Sebagai contoh, ambil bilangan yang sama seperti sebelumnya:

115 109 116 117 114 114 049 112 122 110

049 109 115 116 114 114 112 110 117 122

049 109 110 115 114 114 112 116 117 122

049 109 110 112 114 114 115 116 117 122

(39)

Namun, proses belum berhenti karena ditemukan 2 angka yang sama (huruf s dalam

tabel ASCII). Untuk mengetahui urutan mana yang terlebih dahulu, maka pengurutan

dilanjutkan pada karakter kedua pada kedua string tersebut (r4rf8j dan rstau0).

4=052

s=115

052 115

Maka hasil pengurutan 10 string tersebut dapat dilihat pada Gambar 4.9.

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

049 109 110 112 114 114 115 116 117 122

1 m n p R r s t u z

052 115

4 S

A5 A6

052 115

(40)

(41)

4.4.2. Analisis kompleksitas waktu (Tn) dan grafik perbandingan algoritma 3 Way

Quicksort

grafik running time algoritma 3 Way QuickSort (Gambar 4.10)

hdc

115 109 116 117 114 114 049 112 122 110

109

049 115 116 117 ₁₂₂

049 109 110 116 117 122

049 109 110 112 114 114 115 116 117 122 114 114 112

112 115 114 114

(42)

= n log n + n

= θ( n log n)

Tabel 4.2 Running Time Perbandingan Algoritma 3 Way QuickSort a. Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB

n 3 Way QuickSort (satuan waktu milidetik)

60 1

600 2

6000 7

60000 55

Gambar di bawah ini menunjukkan grafik perbandingan algoritma 3 Way QuickSort

a. Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB n 3 Way QuickSort (satuan waktu milidetik)

60 0

600 3

6000 15

(43)

Gambar 4.10 Grafik Running Time Perbandingan Algoritma 3 Way QuickSort

4.5. Algoritma RadixSort

Dalam tahapan ini, compiler melakukan pengurutan secara RadixSort berdasarkan

jumlah data yang telah dibangkitkan. Dalam hal ini, kita ambil contoh dengan n = 100

strings. Dalam proses compile (Gambar 4.11), akan terlihat berapa lama proses yang

dibutuhkan untuk mengeksekusi data tersebut. Hasil pengurutan berdasarkan

Algoritma RadixSort (.txt) juga dapat dilihat pada Gambar 4.12.

(44)

(45)

4.5.1. Analisis algoritma RadixSort

Langkah-langkah pengurutan RadixSort adalah sebagai berikut:

1. Data dibagi sesuai digit terkanan

115 109 116 117 114 114 049 112 122 110

Kategori Digit Isi

2. Hasil pengategorian tersebut lalu digabungkan kembali dengan metode

kongkatenasi menjadi:

110 112 122 114 114 115 116 117 109 049

3. Kemudian pengategorian dilakukan kembali, namun kali ini berdasar digit

kedua atau digit tengah, dan jangan lupa bahwa urutan pada tiap sub

kumpulan data harus sesuai dengan urutan kemunculan pada kumpulan data

110 112 122 114 114 115 116 117 109 049

Kategori Digit Isi

0 109

1 110,112,114,114,115,116,117

2 122

(46)

-5

-6

-7

-8

-9

-4. Kemudian dikongkatenasikan kembali menjadi:

109 110 112 114 114 115 116 117 122 049

5. Pengategorian kembali berdasar digit yang terkiri, atau yang paling

signifikan

109 110 112 114 114 115 116 117 122 049

Kategori Digit Isi

6. Dan kemudian kongkatenasikan kembali, yang merupakan hasil akhir dari

pengurutan berdasarkan RadixSort

049 109 110 112 114 114 115 116 117 122

(47)

maka pengurutan dilanjutkan pada karakter kedua pada kedua string tersebut

(r4rf8j dan rstau0).

4=052

s=115

052 115

kedua atau digit tengah, dan jangan lupa bahwa urutan pada tiap sub

kumpulan data harus sesuai dengan urutan kemunculan pada kumpulan

(48)

052 115

10. Kemudian dikongkatenasikan kembali menjadi:

115 052

(49)

052 115

13. Hasil akhir untuk pengurutan karakter kedua pada kedua string tersebut

(r4rf8j dan rstau0)

A5 A6

052 115

4 S

14. Maka hasil pengurutan 10 string tersebut dapat dilihat pada Gambar 3.6.

A1 A2 A3 A4 A5 A6 A7 A8 A9 A10

049 109 110 112 114 114 115 116 117 122

1 m n p r r S t u z

A5 A6

052 115

(50)

4.5.2. Analisis kompleksitas waktu (Tn) dan grafik perbandingan algoritma

RadixSort

grafik running time algoritma RadixSort (Gambar 4.14)

3 bit

c = jumlah bit (konstan) = 3

T(n) = c.n

T(n) = 6n

RadixSort = θ(n)

Tabel 4.3 Running Time Perbandingan Algoritma RadixSort a. Intel®Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB

115 109 116 117 114 114 049 112 122 110

110 112 122 114 114 115 116 117 109 122

109 110 112 114 114 115 116 117 122 049

049 109 110 112 114 114 115 116 117 122

n RadixSort (satuan waktu milidetik)

60 0

600 1

6000 6

60000 47

n RadixSort (satuan waktu milidetik)

60 0

600 2

6000 15

(51)

Gambar di bawah ini menunjukkan grafik perbandingan algoritma RadixSort

a. Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB

Gambar 4.14 Grafik Running Time Perbandingan Algoritma RadixSort

4.6. Kesimpulan Analisis Keseluruhan Algoritma

Dalam penelitian ini, penulis menganalisis algoritma berdasarkan kompleksitas waktu

(T(n)) dan running time ketiga algoritma sorting tersebut. Berdasarkan Gambar 4.15,

Gambar 4.16, Tabel 4.4, ataupun Tabel 4.5 di bawah, dapat disimpulkan bahwa:

1. Waktu yang diperlukan untuk memproses suatu algoritma tergantung pada

(52)

QuickSort memiliki kompleksitas waktu T(n) n log n dan Radix Sort dengan

T(n) n yang dihitung berdasarkan tahapan penyelesaian proses pengurutan

data.

2. Waktu yang diperlukan untuk untuk memproses suatu algoritma tergantung

pada platform nya, seperti: proses CPU, processor, bahasa pemrograman, dan

RAM. Waktu yang diperlukan ketiga algoritma sorting pada Intel Pentium

P6300, RAM 3GB, HDD 320 GB secara rata-rata dapat simpulkan lebih

lambat daripada Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB,

HDD 500 GB.

3. Perhatikan Tabel 4.4 dan Tabel 4.5. Algoritma QuickSort dan 3 Way

QuickSort kurang stabil dalam melakukan percobaan sebanyak 5 kali, namun

untuk Algoritma RadixSort cenderung stabil.

4. Kompleksitas waktu tidak tepat persis dengan running time, karena

kompleksitas waktu adalah perkiraan kebutuhan algoritma sejalan dengan

meningkatnya nilai n sedangkan, running time adalah waktu yang diperlukan

oleh komputer untuk melakukan tahapan komputasi. Namun kompleksitas

waktu berbanding lurus dengan running time. Hal ini dapat dilihat dari nilai

T(n) dan grafik algoritma sorting tersebut. Algoritma QuickSort dan 3 Way

QuickSort memiliki kompleksitas waktu yang sama yaitu, T(n) n log n.

Namun, grafik yang dihasilkan algoritma tersebut berbeda. Algoritma 3 Way

QuickSort lebih unggul dalam proses nya karena sesungguhnya kompleksitas

waktu T(n) algoritma 3 Way QuickSort n log n + n dan T(n) algoritma

QuickSort n log n + 2n, dimana lebih cepat daripada . Namun,

kompleksitas waktu T(n) algoritma RadixSort adalah 6n, yang menunjukkan

algoritma RadixSort lebih unggul dari kedua algoritma lain. Oleh sebab itu,

urutan algoritma sorting dari yang paling cepat hingga yang paling lambat

(53)

Gambar 4.15 Grafik Running Time Seluruh Algoritma pada Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB.

(54)

Tabel 4.4 Running Time Seluruh Algoritma pada Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB

a. Algoritma QuickSort

n 60 600 6000 60000

Percobaan ke 1

b. Algoritma 3 Way QuickSort

n 60 600 6000 60000

(55)

c. Algoritma RadixSort

n 60 600 6000 60000

Percobaan ke 1

Tabel 4.5 Running Time Seluruh Algoritma pada Intel Pentium P6300, RAM 3GB, HDD 320 GB

a. Algoritma QuickSort

n 60 600 6000 60000

(56)

b. Algoritma 3 Way QuickSort

n 60 600 6000 60000

Percobaan ke 1

n 60 600 6000 60000

(57)

(58)

Bab ini berisi kesimpulan dari seluruh bab sebelumnya, serta saran yang diharapkan

dapat bermanfaat dalam proses pengembangan penelitian selanjutnya.

5.1. Kesimpulan

Berdasarkan hasil studi literatur, analisis, perancangan, implementasi, dan pengujian

sistem, maka kesimpulan yang penulis sampaikan adalah sebagai berikut:

1. Kompleksitas waktu diperlukan sebagai acuan dalam menentukan perhitungan

secara teori untuk mendapatkan satuan waktu yang diperlukan dalam pengurutan

data.

2. Pengurutan data yang penulis lakukan berdasarkan pengurutan ascending

(menaik). Data acak yang disajikan diurutkan berdasarkan string 6 karakter

sesuai tabel ASCII.

3. Waktu pengurutan ketiga algoritma sorting (QuickSort, 3 Way QuickSort

RadixSort) dengan spesifikasi laptop Intel Core I5 2520m 2,50 GHz 3MB Cache,

RAM 2 GB, HDD 500 GB lebih cepat daripada Intel Pentium P6300, RAM

3GB, HDD 320 GB. Rata-rata waktu pengurutan dengan spesifikasi laptop Intel

Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB 2 kali lebih

cepat untuk setiap n data.

4. Waktu pengurutan algoritma RadixSort lebih cepat daripada algoritma

QuickSort dan 3 Way QuickSort. Kompleksitas waktu (Tn) RadixSort c.n,

dimana c merupakan panjang bit data yang menyebabkan algoritma ini begitu

cepat dibandingkan algoritma QuickSort dan 3 Way QuickSort n log n. Oleh

karena itu, waktu pengurutan algoritma RadixSort jauh lebih efisien daripada

(59)

Hal ini membuktikan bahwa, waktu pengurutan tergantung pada algoritma, jumlah

data, dan platform yang digunakan.

5.2. Saran

Adapun saran-saran yang dapat diberikan penulis untuk pengembangan dan perbaikan

sistem ini selanjutnya adalah sebagai berikut:

1. Penelitian ini dapat dikembangkan dengan desain yang lebih user friendly.

2. Diharapkan pada penelitian selanjutnya untuk memilih algoritma yang lain, baru

dan unik, seperti Cocktail ShakerSort, 2 Way QuickSort, RadixQuickSort,

Radix3WayQuickSort, dan lain sebagainya.

3. Dalam penelitian selanjutnya, juga diharapkan untuk menggunakan spesifikasi

laptop/komputer yang lebih tinggu untuk melihat signifikan perbedaan

(60)

2.1. Algoritma

Secara informal, sebuah algoritma adalah prosedur komputasi yang didefinisikan

dengan baik yang mengambil beberapa nilai, atau seperangkat nilai sebagai input dan

menghasilkan nilai, atau seperangkat nilai sebagai output[2].

Algoritma yang akan dianalisis dan dibandingkan pada penelitian ini adalah

algoritma Sorting (pengurutan) yaitu algoritma QuickSort, 3 Way QuickSort, dan

RadixSort. Algoritma pengurutan adalah algoritma yang menyusun kembali rentetan

objek-objek untuk meletakkan objek suatu kumpulan data tersebut ke dalam urutan

yang logis [9]. Algoritma adalah prosedur komputasi yang didefinisikan dengan baik

yang mengambil beberapa nilai yaitu seperangkat nilai sebagai input dan output yang

menghasilkan nilai. Algoritma juga merupakan pola pikir terstruktur yang berisi

tahapan penyelesaian, yang nantinya akan diimplementasikan ke dalam suatu bahasa

pemrograman [6]. Berdasarkan pengertian algoritma tersebut, dapat disimpulkan

bahwa algoritma merupakan suatu istilah yang luas, yang tidak hanya berkaitan

dengan dunia komputer.

Menurut Donald E. Knuth, algoritma yang baik memiliki kriteria sebagai

berikut:

1. Input

Suatu algoritma harus memiliki 0 (nol) atau lebih masukan (input). Artinya,

suatu algoritma itu dimungkinkan tidak memiliki masukan secara langsung

dari pengguna tetapi dapat juga memiliki beberapa masukan. Algoritma

yang tidak memiliki masukan secara langsung dari pengguna, maka semua

(61)

2. Output

Suatu algoritma harus memiliki satu atau lebih algoritma. Suatu algoritma

yang tidak memiliki keluaran (output) adalah suatu algoritma yang sia-sia,

yang tidak perlu dilakukan. Algoritma dibuat untuk tujuan menghasilkan

sesuatu yang diinginkan, yaitu berupa hasil keluaran.

3. Finiteness

Setiap pekerjaan yang dikerjakan pasti berhenti. Demikian juga algoritma

harus dapat dijamin akan berhenti setelah melakukan sejumlah langkah proses.

4. Definiteness

Algoritma tersebut tidak menimbulkan makna ganda (ambiguous). Setiap baris

aksi/pernyataan dalam suatu algoritma harus pasti, artinya tidak menimbulkan

penafsiran lain bagi setiap pembaca algoritma, sehingga memberikan output

yang sesuai dengan yang diharapkan oleh pengguna.

5. Effectiveness

Setiap langkah algoritma harus sederhana sehingga dikerjakan dalam waktu

yang wajar.[10]

2.2. Kompleksitas Algoritma

Dalam aplikasinya, setiap algoritma memiliki dua buah ciri khas yang dapat

digunakan sebagai parameter pembanding, yaitu jumlah proses yang dilakukan dan

jumlah memori yang digunakan untuk melakukan proses. Jumlah proses ini dikenal

sebagai kompleksitas waktu yang disimbolkan dengan T(n), sedangkan jumlah

memori ini dikenal sebagai kompleksitas ruang yang disimbolkan dengan S(n).[12]

2.2.1. Kompleksitas waktu

Kompleksitas waktu T(n), diukur dari jumlah tahapan komputasi yang dibutuhkan

untuk menjalankan algoritma sebagai fungsi dari ukuran masukan n. Jumlah tahapan

komputasi dihitung dari berapa kali suatu operasi dilaksanakan di dalam sebuah

algoritma sebagai fungsi ukuran masukan (n).

Hal-hal yang mempengaruhi kompleksitas waktu:

(62)

Ruang memori yang dibutuhkan untuk menjalankan algoritma yang berkaitan

dengan strutur data dari program.[1]Oleh karena itu, pada komputer dan compiler yang

berbeda, suatu algoritma yang sama akan memiliki waktu eksekusi yang berbeda.

2.2.2. Kompleksitas waktu asimptotik

Notasi “O” disebut notasi “O-Besar” (Big-O) yang merupakan notasi kompleksitas

waktu asimptotik. Kompleksitas waktu asimptotik merupakan perkiraan kebutuhan

algoritma sejalan dengan meningkatnya nilai n. Pada umumnya, algoritma

menghasilkan laju waktu yang semakin lama bila nilai n semakin besar. Berikut

pengelompokan algoritma berdasarkan notasi O-Besar dapat dilihat pada Tabel 2.1.

Tabel 2.1. Pengelompokan algoritma berdasarkan notasi O-Besar

Keterangan Tabel:

1. Konstan O(1): Disebut konstan, karena program hanya dieksekusi dengan

suatu nilai yang konstan.

2. Logaritmik O(log n): Disebut algoritma logaritmik, karena peningkatan waktu

eksekusi sebanding dengan peningkatan logaritma dari jumlah data.

3. Linear O(n): Disebut linear, karena peningkatan waktu eksekusi sebanding

dengan peningkatan data, dan merupakan kondisi optimal dalam membuat

algoritma.

4. Linearitmik O(n log n): Disebut linearitmik, karena merupakan gabungan dari

No Kelompok Algoritma Nama

1 O(1) Konstan

2 O(log n) Logaritmik

3 O(n) Linear

4 O(n log n) Linearitmik

5 O(n2) Kuadratik

6 O(n3) Kubik

7 O(nm) Polinomial

(63)

dijalankan sebanyak n kali. Biasanya digunakan untuk memecahkan masalah

besar menjadi masalah yang kecil.

5. Kuadratik O(n2): Disebut kuadratik, karena peningkatan waktu eksekusi

program akan sebanding dengan peningatan kuadrat jumlah data.

6. Kubik O(n3): Disebut kubik, karena peningkatan waktu eksekusi program akan

sebanding dengan peningkatan pangkat tiga jumlah data.

7. Polinomial O(nm): Algoritma yang tidak efisien, karena memerlukan jumlah

langkah penyelesaian yang jauh lebih besar daripada jumlah data.

8. Faktorial O(n!): Merupakan algoritma yang paling tidak efisien, karena waktu

eksekusi program akan sebanding dengan peningkatan faktorial jumlah data.

Gambar 2.1. Grafik Perbandingan Pengelompokan Algoritma Berdasarkan Notasi O-Besar

2.2.3. Kompleksitas ruang

Kompleksitas ruang (Sn) adalah jumlah memori yang dibutuhkan oleh komputer untuk

menjalankan sebuah algoritma sampai selesai. Kompleksitas ruang (Sn) diukur

berdasarkan struktur data yang digunakan di dalam algoritma sebagai fungsi dari

(64)

2.3. Running Time

Running time adalah waktu yang digunakan oleh sebuah algoritma untuk

menyelesaikan masalah pada sebuah komputer paralel dihitung mulai dari saat

algoritma mulai hingga saat algoritma berhenti. Jika prosesor-prosesornya tidak mulai

dan selesai pada saat yang bersamaan, maka running time dihitung mulai saat

komputasi pada prosesor pertama dimulai hingga pada saat komputasi pada prosesor

terakhir selesai.

2.4. Pengurutan

Pengurutan merupakan proses yang menyusun kembali rentetan objek-objek untuk

meletakkan objek dari suatu kumpulan data ke dalam urutan yang logis. Pada

dasarnya, pengurutan (sorting) membandingkan antar data atau elemen berdasarkan

kriteria dan kondisi tertentu.[4] Ada dua jenis pengurutan, yakni secara ascending

(naik) dan descending (turun).

Ada dua kategori pengurutan, yaitu:

1. Pengurutan internal

Pengurutan internal adalah pengurutan yang dilaksanankan hanya dengan

menggunakan memori komputer, pada umumnya digunakan bila jumlah elemen

tidak terlalu banyak.

2. Pengurutan eksternal

Pengurutan eksternal adalah pengurutan yang dilaksanakan dengan bantuan

memori virtual atau harddisk karena jumlah elemen yang akan diurutkan terlalu

banyak.

2.5. Klasifikasi Algoritma Pengurutan

Algoritma pengurutan diklasifikasikan berdasarkan prosesnya menjadi beberapa jenis,

yakni,

1. Exchange Sort

Algoritma yang dikategorikan dalam Exchange Sort jika cara kerja algoritma

tersebut melakukan pembandingan antar data dan melakukan pertukaran

(65)

2. Selection Sort

Algoritma yang dikategorikan dalam Selection Sort jika cara kerja algoritma

tersebut mencari elemen yang tepat untuk diletakkan pada posisi yang telah

diketahui, dan meletakkannya di posisi tersebut setelah data tersebut

ditemukan. Contohnya adalah selection sort, heap sort, smooth sort, strand

sort.

3. Insertion Sort

Algoritma yang dikategorikan dalam Insertion Sort jika cara kerja algoritma

tersebut mencari tempat yang tepat untuk suatu elemen data yang telah

diketahui ke dalam subkumpulan data yang telah terurut, kemudian melakukan

penyisipan (insertion) data di tempat yang tepat tersebut. Contohnya adalah

insertion sort, shell sort, tree sort, library sort, patience sort.

4. Merge Sort

Algoritma yang dikategorikan dalam Merge Sort jika cara kerja algoritma

tersebut membagi data menjadi subkumpulan-subkumpulan yang kemudian

subkumpulan tersebut diurutkan secara terpisah, dan kemudian digabungkan

kembali dengan metode merging. algoritma ini melakukan metode pengurutan

merge sort juga untuk mengurutkan subkumpulandata tersebut, atau dengan

kata lain, pengurutan dilakukan secara rekursif. Contohnya adalah merge sort.

5. Non Comparison Sort

Algoritma yang dikategorikan dalam Non Comparison Sort jika proses

pengurutan data yang dilakukan algoritma tersebut tidak terdapat pembanding

antar data, data diurutkan sesuai dengan pigeon hole principle. Contohnya

adalah radix sort, bucket sort, counting sort, pigeonhole sort, tally sort.

2.6. Algoritma QuickSort

Algoritma QuickSort merupakan teknik pengurutan yang dikemukakan pertama kali

oleh C.A.R Hoare pada tahun 1962. Metode penyelesaiannya menggunakan

pendekatan rekursif[5]. QuickSort disebut juga sebagai Partition Exchange Sort.

Disebut QuickSort karena terbukti mempunyai kemampuan average behaviour yang

(66)

karena proses pengurutan menggunakan partisi dan pengurutan dilakukan pada setiap

partisi[7].

2.6.1. Langkah-langkah melakukan pengurutan algoritma QuickSort

Tahapan dalam melakukan partisi pada Algoritma QuickSort sebagai berikut:

1. Pilih x Є {A1, A2, ... , An} sebagai elemen pivot (x)

2. Lakukan scanning tabel dari kiri ke kanan sampai ditemukan Ap≥x

3. Lakukan scanning tabel dari kanan ke kiri sampai ditemukan Aq≤x

4. Swap Ap↔ Aq

5. Ulangi langkah ke-2, sampai kedua scanning bertemu di tengah tabel.

Untuk menetukan pivot, ada baiknya dari median tabel. Sebagai contoh, ambil

bilangan acak:

523 235 088 880 028 093 002 153

1. Menentukan pivot

A1 A2 A3 A4 A5 A6 A7 A8

523 235 088 880 028 093 002 153

x

A1 A2 A3 A4 A5 A6 A7 A8

523 235 088 880 028 093 002 153

p x q

3. Swap Ap↔ Aq

A1 A2 A3 A4 A5 A6 A7 A8

002 235 088 880 028 093 523 153

(67)

A1 A2 A3 A4 A5 A6 A7 A8

002 235 088 880 028 093 523 153

p x

q

5. Swap Ap↔ Aq

A1 A2 A3 A4 A5 A6 A7 A8

002 028 088 880 235 093 523 153

p x

q

6. Mengulangi langkah ke-2, karena pivot telah berubah

A1 A2 A3 A4 A5 A6 A7 A8

002 028 088 880 235 093 523 153

p x q

7. Swap Ap↔ Aq

A1 A2 A3 A4 A5 A6 A7 A8

002 028 088 153 235 093 523 880

p x q

scanning bertemu ditengah table

A1 A2 A3 A4 A5 A6 A7 A8

002 028 088 153 235 093 523 880

x

p

(68)

9. Swap Ap↔ Aq, berhenti karena p≤q di tengah tabel

A1 A2 A3 A4 A5 A6 A7 A8

002 028 088 153 093 235 523 880

x

p

q

10. Membagi partisi menjadi 2 tabel:

Hasil partisi pertama:

A1 A2 A3 A4 A5

002 028 088 153 093

A1 A2 A3 A4 A5

002 028 088 153 093

x

A1 A2 A3 A4 A5

002 028 088 153 093

x

p

q

13. Swap Ap↔ Aq, berhenti karena p≤q di tengah tabel

A1 A2 A3 A4 A5

002 028 088 093 153

x

p

q

Hasil partisi kedua:

(69)

A6 A7 A8

235 523 880

x

scanning tabel dari kanan ke kiri sampai ditemukan Aq≤x. Dan ternyata,

tidak dapat melakukan scanning karena syarat tidak memenuhi. Oleh

karena itu, hasil scanning partisi kedua selesai dan merupakan hasil akhir

pemartisian.

A6 A7 A8

235 523 880

x

16. Hasil akhir merupakan gabungan antara hasil akhir proses partisi pertama

dan kedua

A1 A2 A3 A4 A5 A6 A7 A8

002 028 088 093 153 235 523 880

2.6.2. Pseudocode algoritma QuickSort

Menurut Fachrie Lantera, 2008 pseudocode pada algoritma QuickSort adalah sebagai

berikut:

Procedure QuickSort (input/output a : array [1..n] of integer, input i,j : integer )

Deklarasi :

{mengurutkan tabel a[i..j] dengan algoritma QuickSort.

Masukkan: Tabel a[i..j] yang sudah terdefinisi elemen-elemennya.

Keluaran: Tabel a[i..j] yang terurut menaik.}

(70)

if (i<j) then

Partisi(a,i,j,k) {Ukuran (a) > 1} QuickSort(a,i,k)

QuickSort(a,k+1, j) End if

Procedure Partisi (input/output: a : array[1..n] of integer, input i, j : integer, output q : integer)

{Membagi tabel a[i..j] menjadi dua tabel a[i..q] dan a[q+1..j]

scanning a[i..q] dan a[q+1..j] Sedemikian sehingga elemen tabel a[i..q] lebih kecil

dari elemen tabel a[q+1..j] }

Deklarasi :

Pivot, temp : integer Algoritma :

while a[p] < pivot do p <- p + 1

endwhile

{ Ap >= pivot }

while a[q] > pivot do q <- q – 1

endwhile

{ Aq >= pivot } if (p >q) then

{ pertukarkan a[p] dengan a[q]} temp <- a[p]

(71)

{ tentukan awal pemindaian berikutnya } p <- p+ 1

q <- q - 1 endif

until p > q

2.6.3. Kompleksitas waktu asimptotik algoritma QuickSort

Terdapat 3 kemungkinan kasus dari performa algoritma QuickSort ini yaitu, terbaik

dan rata-rata (best and average case= n log n), serta terburuk (worst case= n2).

Kompleksitas waktu asimptotik algoritma QuickSort adalah O (n log n). Oleh karena

itu, dapat disimpulkan algoritma ini termasuk “linearitmik”. Karena merupakan

algoritma log n yang dijalankan sebanyak n kali. Dan digunakan untuk memecahkan

masalah besar menjadi masalah yang kecil sangat sesuai dengan algoritma QuickSort

yang bersifat divide and conquer.

2.7. Algoritma 3 Way QuickSort

Algoritma 3 Way QuickSort pertama kali dikemukakan oleh Sedgewick. 3 Way

QuickSort merupakan pengembangan dari algoritma QuickSort dengan membagi array

menjadi 3 bagian, yaitu: array < v, array =v, dan array > v. Dimana v merupakan

elemen pivot. Dan mempartisinya berdasarkan partisi QuickSort.

2.7.1. Langkah-langkah melakukan pengurutan algoritma 3 Way QuickSort

Mekanisme pengurutannya adalah sebagai berikut:

1. Pilih x1, x2, x3Є {A1, A2, ... , An} sebagai elemen pivot (x1, x2, x3)

2. Susun pivot dengan syarat x1 > x2 > x3

3. Atur semua data selain pivot (x1, x2, x3) sesuai urutan kemunculan dengan

syarat data yang lebih kecil dari pivot (x1, x2, x3) berada di sebelah kiri pivot

dan data yang lebih besar atau sama dengan pivot berada di sebelah kanan

pivot.

4. Ulangi langkah pertama hingga keseluruhan data terurut (A1<A2<A3...<An)

(72)

523 235 088 880 028 093 002 153

002 028 088 093 153 235 523 880

2.7.2. Pseudocode algoritma 3 Way QuickSort

Deklarasi :

Procedure ThreeWayQuickSort (input/output a : arr [1..r] of integer, input i, lt, gt, v : integer )

(73)

gt<- gt-1

while pivot=(pivot+1 || pivot-1) && gt>pivot do Partisi

endwhile endif

if a[i]=pivot then i<- i+1

while pivot=(pivot+1 || pivot-1) && gt>pivot do Partisi

endwhile endif

Procedure Partisi (input/output: a :array[1..r] of integerinput i, j : integer, output q : integer)

{Membagi tabel a[i..j] menjadi dua tabel a[i..q] dan a[q+1..j]

scanning a[i..q] dan a[q+1..j] Sedemikian sehingga elemen tabel a[i..q] lebih kecil

dari elemen tabel a[q+1..j] }

Deklarasi :

Pivot, temp : integer Algoritma :

while a[p] < pivot do p <- p + 1

endwhile

{ Ap >= pivot }

(74)

endwhile

{ Aq >= pivot } if (p >q) then

{ pertukarkan a[p] dengan a[q]} temp <- a[p]

a[p] <- a[q] a[q] <- temp

{ tentukan awal pemindaian berikutnya} p <- p+ 1

q <- q - 1 endif

until p > q

2.7.3. Kompleksitas waktu asimptotik algoritma 3 Way QuickSort

Algoritma 3 Way QuickSort ini adalah algoritma yang tidak stabil dan memiliki

kompleksitas yang sama dengan QuickSort yaitu, terbaik dan rata-rata (best and

average case= n log n), dan kasus terburuk (worst case = n2). Kompleksitas waktu

asimptotik algoritma 3 Way QuickSort adalah O (n log n).

2.8. Algoritma RadixSort

Algoritma RadixSort merupakan algoritma pengurutan yang cepat, mudah, dan sangat

efektif. Namun banyak orang yang berpikir bahwa algoritma ini memiliki banyak

batasan di mana untuk kasus- kasus tertentu tidak dapat dilakukan dengan algoritma

ini, seperti pengurutan bilangan pecahan, bilangan negatif, adanya kompleksitas bit

dan word, dan pengurutan pada multiple keys. RadixSort hanya bisa digunakan pada

bilangan integer, untuk bilangan pecahan, bisa dilakukan dengan perantara bucket sort

atau metode berbasis perbandingan yang lain. Dalam perilakunya yang melihat

digit-digit angka sebagai pengontrolnya, RadixSort dapat dimplementasikan dalam

(75)

2.8.1. Langkah-langkah melakukan pengurutan algoritma RadixSort

Langkah-langkah pengurutan RadixSort adalah sebagai berikut:

523 235 088 880 028 093 002 153

Kategori Digit Isi

880 002 523 093 153 235 088 028

kedua atau digit tengah, dan jangan lupa bahwa urutan pada tiap

subkumpulan data harus sesuai dengan urutan kemunculan pada kumpulan

data

880 002 523 093 153 235 088 028

Kategori Digit Isi

0 002

(76)

-3 235

4. Kemudian dikongkatenasikan kembali menjadi:

002 523 028 235 153 880 088 093

signifikan

002 523 028 235 153 880 088 093

Kategori Digit Isi

(77)

2.8.2. Pseudocode algoritma RadixSort

Menurut Dominikus DP (2005) pseudocode pada Algoritma RadixSort adalah sebagai

berikut :

Procedure RadixSort (A : T Array; var B :T Array; d : byte); var

KatRadix : array[0..9] of Queue;

i, x, ctr : integer;

pembagi : longword;

begin

{--- inisialisasi KatRadix ---}

for i:=0 to 9 do

InitQueue (KatRadix[i]);

{--- dikategorikan ---}

for i:=1 to n do

Enqueue (KatRadix [(B[i] div

pembagi) mod 10], B[i]);

B[i] := 0;

while (NOT IsQueueEmpty(KatRadix[i])) do

(78)

B[ctr]:=DeQueue (KatRadix [i]);

endwhile

end;

pembagi := pembagi * 10;

end;

2.8.3. Kompleksitas waktu asimptotik algoritma RadixSort

Kompleksitas waktu asimptotik Algoritma RadixSort adalah O(nd). Secara umum,

Algoritma RadixSort memiliki kompleksitas waktu asimptotiknya yang sangat kecil

(O(kN)). Dimana k merupakan panjang digit terpanjang dalam kumpulan data. Dalam

hal ini, dikategorikan ke dalam “linear” karena bentuk O(kN) sebanding dengan O(n),

(79)

1.1. Latar Belakang

Sorting atau pengurutan merupakan proses mengatur susunan data menurut kriteria

tertentu. Meskipun sepertinya hanya sebuah masalah klasik, pengurutan memiliki

peranan penting dalam mengolah data. Dengan adanya metode pengurutan ini, data

yang disajikan secara acak dapat disusun dengan teratur.

Data merupakan informasi yang telah diterjemahkan ke dalam bentuk yang

lebih sederhana untuk melakukan suatu proses. Pencarian informasi yang berjumlah

besar dalam waktu yang cepat sangat dibutuhkan sebagai upaya efisiensi waktu.

Untuk mengurutkan data tersebut, algoritma sorting merupakan metode yang

mampu menyelesaikannya. Algoritma pengurutan ini dapat diklasifikasikan

berdasarkan teknik proses pengurutan data, yaitu: Divide and Conquer dan bukan

Divide and Conquer. Secara kompleksitas waktu, RadixSort termasuk ke dalam

Divide and Conquer. Namun dari segi algoritma untuk melakukan proses pengurutan,

RadixSort tidak termasuk dalam Divide and Conquer. Sedangkan QuickSort dalam

melakukan proses pengurutan data menggunakan teknik Divide and Conquer.

Divide and Conquer adalah teknik pemecahan masalah dengan membagi dan

menggabungkan. Membagi masalah menjadi bagian yang lebih kecil, kemudian

menyelesaikan masalah yang telah dibagi tersebut secara independen, lalu

menggabungkan solusi dari masalah yang telah diselesaikan tersebut menjadi solusi

dari masalah semula. Algoritma RadixSort adalah algoritma sorting yang cepat, unik,

dan efektif dan algoritma QuickSort memiliki proses yang cepat dan mudah

diimplentasikan. Dengan memanfaatkan kelebihan dari kedua jenis algoritma tersebut,

maka penulis ingin menganalisis kompleksitas waktu algoritma sorting tersebut

(80)

Namun, untuk algoritma QuickSort, penulis ingin menganalisis satu algoritma

lainnya dari Quick Sort, yakni 3 Way QuickSort yang lebih unggul dalam pengurutan

data yang duplikat. Berdasarkan hal yang telah dipaparkan, maka penulis memilih

judul “Analisis Pe_{rbandingan Algoritma QuickSort, 3 Way QuickSort, dan} RadixSort. ”

1.2. Rumusan Masalah

Rumusan masalah dalam penelitian ini adalah bagaimana merancang program

pengurutan untuk menganalisis kompleksitas waktu dari algoritma QuickSort, 3 Way

QuickSort, dan RadixSort pada pengurutan string.

1.3. Batasan Masalah

Adapun batasan masalah pada penelitian ini adalah:

1. Hanya membahas mengenai algoritma QuickSort, 3 Way QuickSort dan

RadixSort dalam pengurutan string

2. Hanya menganalisis perbandingan kompleksitas waktu (big-O) algoritma

QuickSort, 3 Way QuickSort dan RadixSort

3. Data yang digunakan merupakan data yang dibangkitkan secara acak berupa

string (kombinasi huruf dan angka) dengan 6 karakter

4. Pengurutan data acak dengan data<=10.000 string

5. Hasil output berupa pengurutan string ascending berdasarkan ASCII

6. Aplikasi yang dirancang menggunakan bahasa pemrograman C++

7. Menggunakan laptop dengan spesifikasi:

a. Intel Core I5 2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB.

(81)

1.4. Tujuan Penelitian

Tujuan dari penelitian ini adalah mampu mengurutkan string berdasarkan pengurutan

ASCII menggunakan algoritma QuickSort, 3 Way QuickSort dan RadixSort dari string

acak yang dibangkitkan serta mampu menganalisis kompleksitas ketiga algoritma

tersebut.

1.5. Manfaat Penelitian

Adapun manfaat dari penelitian ini yaitu:

1. Memahami bagaimana cara menganalisis kompleksitas waktu algoritma

QuickSort, 3 Way QuickSort dan RadixSort dalam pengurutan string acak.

2. Dapat dijadikan pembelajaran dan menambah pengalaman di bidang keilmuan

yang terkait.

1.6. Metodologi Penelitian

Metodologi penelitian yang digunakan dalam penulisan tugas akhir ini adalah sebagai

berikut:

1. Studi Literatur

Penulis mengumpulkan bahan dan data referensi dari buku, skripsi dan sumber

lain yang berkaitan dengan kompleksitas waktu (big-O) dan running time.

2. Analisis dan Perancangan Sistem

Pada tahap ini dilakukan analisis sesuai dengan kebutuhan seperti cara

membangun program pengurutan algoritma QuickSort, 3 Way QuickSort dan

RadixSort, pembuatan flowchart, input, serta output yang diinginkan.

3. Implementasi Sistem

Metode ini dilaksanakan dengan mengimplementasikan rancangan sistem yang

telah dibuat pada analisis dan perancangan sistem ke dalam program komputer

dengan menggunakan bahasa pemrograman C++.

4. Pengujian Sistem

Metode ini dilaksanakan dengan mengimplementasikan algoritma QuickSort, 3

(82)

Hasil program diuji kemudian dianalisis apakah sistem ini bekerja secara

efektif dan efisien.

5. Dokumentasi

Metode ini berisi laporan dan kesimpulan akhir dari hasil analisis dan

pengujian dalam bentuk skripsi.

1.7. Sistematika Penulisan

Sistematika penulisan dalam penelitian ini, yaitu:

BAB 1: PENDAHULUAN

Bab ini berisi latar belakang masalah, rumusan masalah, batasan masalah, tujuan

penelitian, manfaat penelitian, metodologi penelitian dan sistematika penulisan

skripsi.

BAB 2: LANDASAN TEORI

Bab ini membahas mengenai teori-teori yang digunakan untuk memahami

permasalahan yang berkaitan dengan proses pengurutan algoritma QuickSort, 3 Way

QuickSort dan RadixSort.

BAB 3: ANALISIS DAN PERANCANGAN SISTEM

Pada bab ini berisi analisis mengenai metode yang digunakan untuk menyelesaikan

masalah dan perancangan dari sistem yang dibangun.

BAB 4: IMPLEMENTASI SISTEM

Bab ini berisi tentang pengujian program yang telah diimplentasikan dengan

menggunakan bahasa pemograman C++.

BAB 5: KESIMPULAN DAN SARAN

Bab ini berisi kesimpulan yang telah dirangkum dalam penelitian ini dan berisi saran

yang berguna dalam usaha untuk melakukan perbaikan dan pengembangan penelitian

(83)

Pengurutan merupakan proses menyusun kembali data yang sebelumnya disusun

dengan suatu pola tertentu sehingga tersusun secara teratur menurut aturan tertentu.

Dengan adanya metode pengurutan ini, data yang disajikan secara acak dapat disusun

dengan teratur. Algoritma pengurutan yang digunakan dalam penelitian ini adalah:

QuickSort, 3 Way QuickSort, dan RadixSort. Algoritma QuickSort dan 3 Way

QuickSort merupakan algoritma pengurutan data yang menggunakan pemecahan data

menjadi partisi-partisi. Perbedaannya, algoritma QuickSort memiliki 1 pivot,

sedangkan algoritma 3 Way QuickSort memiliki 3 pivot. Algoritma RadixSort

merupakan salah satu algoritma pengurutan tanpa perbandingan yang dilakukan

dengan cara mengelompokkan data dari digit terkanan dan kemudian

mengkonkatenasikannya. Algoritma RadixSort jauh lebih efisien daripada dua

algoritma lain karena kompleksitas waktu (Tn) RadixSort adalah n.c, sedangkan

QuickSort dan 3 Way QuickSort adalah n log n. Pengurutan data membutuhkan waktu

sehingga dibutuhkan analisis kompleksitas waktu. Kompleksitas waktu dapat dihitung

melalui tahapan pengurutan yang dihitung berdasarkan langkah-langkah algoritma

tersebut dalam memecahkan masalah dan running time algoritma yang dihitung

berdasarkan platform yang digunakan. Oleh karena itu, analisis kompleksitas waktu

mampu menentukan efisiensi waktu suatu algoritma.

Kata Kunci : Pengurutan, QuickSort, 3 Way QuickSort, RadixSort, kompleksitas

(84)

ABSTRACT

Sorting is the process of rearrange the data had arranged with the pattern specific so

that arranged by regularly as the rule specific. By this sorting method, the data served

randomly can be arranged by regular. Sorting algorithm used in this research, i.e:

QuickSort, 3 Way QuickSort, and RadixSort. QuickSort algorithm and 3 Way

QuickSort is data sorting algorithm that uses splitting data into partitions. The

different is QuickSort algorithm have 1 pivot, and 3 Way QuickSort algorithm have 3

pivots. RadixSort algorithm is one of non comparison sorting algorithm that is done by

classifying the data from the most significant digit and then do concatenation.

RadixSort algorithm more efficient than two algorithms other, caused by time

complexity(Tn) of RadixSort algorithm is n.c whereas QuickSort algorithm and 3

Way QuickSort algorithm are n log n. Sorting of data takes time so it take the time

complexity analysis. The time complexity can be calculated by the stages of sorting

based on the steps of the algorithm in solving problems and running time algorithm

based on the platform being used. Therefore, the analysis of time complexity is able

to determine the efficiency of an algorithm.

Keywords : Sorting, QuickSort, 3 Way QuickSort, RadixSort, time complexity,

(85)

SKRIPSI

PLOREN PERONICA PASARIBU 131421038

PROGRAM STUDI EKSTENSI S1 ILMU KOMPUTER FAKULTAS ILMU KOMPUTER DAN TEKNOLOGI INFORMASI

UNIVERSITAS SUMATERA UTARA MEDAN

(86)

SKRIPSI

Diajukan untuk melengkapi tugas dan memenuhi syarat mencapai gelar Sarjana Komputer

PLOREN PERONICA PASARIBU

131421038

`

PROGRAM STUDI EKSTENSI S1 ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER DAN TEKNOLOGI INFORMASI

UNIVERSITAS SUMATERA UTARA

MEDAN

(87)

Judul

:

ANALISIS PERBANDINGAN ALGORITMA

QUICKSORT, 3 WAY QUICKSORT, DAN

RADIXSORT

Kategori : SKRIPSI

Nama : PLOREN PERONICA PASARIBU

Nomor Induk Mahasiswa : 131421038

Program Studi : SARJANA (S1) ILMU KOMPUTER

Fakultas : ILMU KOMPUTER DAN TEKNOLOGI

INFORMASI (FASILKOM-TI) UNIVERSITAS

SUMATERA UTARA

Diluluskan di

Medan, Agustus 2016

Komisi Pembimbing

Dosen Pembimbing II Dosen Pembimbing I

Amer Sharif, S.Si, M.Kom Drs. James Piter Marbun, M.Kom

NIP. - NIP. 1958061119860310002

Diketahui/Disetujui oleh

Program Studi S1 Ilmu Komputer

Ketua,

(88)

ANALISIS PERBANDINGAN ALGORITMA QUICKSORT,

3 WAY QUICKSORT, DAN RADIXSORT

SKRIPSI

Saya mengakui bahwa skripsi ini adalah hasil karya saya sendiri, kecuali beberapa

kutipan dan ringkasan yang masing-masing disebutkan sumbernya.

Medan, Agustus 2016