Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

(1)

// C++ program for generated data

#include <iostream> #include <conio.h> #include <fstream> #include <iomanip> using namespace std;

static const char alphanum[] =

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

{

return alphanum[rand() % stringLength]; } int main() { ofstream out_stream; std::string Str; srand(time(0)); double start=clock();

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 ";

getch(); }

(2)

// C++ program for quicksort #include<iostream> #include<fstream> #include<conio.h> #include<vector> #include<string> #include <iomanip> using namespace std;

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--;

if (i<=j) {

tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; i++;

j--; }

} /* recursion */ if (left < j)

quick_sort(arr, left, j); if (i < right)

quick_sort(arr, i, right); }

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

int i, j; char x, y;

i = left; j = right;

x = items[( left+right) / 2 ]; do

{

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

while((x < items[j]) && (j > left)) j--;

if(i <= j) {

y = items[i];

items[i] = items[j]; items[j] = y;

i++; j--; }

(3)

while(i <= j); if(left < j)

qs(items, left, j); if(i < right)

qs(items, i, right); } int main() { vector<string> data; string tempp; char temppp[6]; int n=0; ifstream ambil; ofstream out_stream;

srand(time(0));// running time double start=clock();

out_stream.open("hasil_quick.txt"); ambil.open("data.txt");

while(!ambil.eof()) //ambil data ke array { getline(ambil, tempp); strcpy(temppp,tempp.c_str()); data.push_back (temppp); } ambil.close(); string dataa[data.size()];

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();

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

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

getch(); }

(4)

// C++ program for 3-way quicksort #include<iostream> #include<fstream> #include<conio.h> #include<vector> #include <iomanip> #include<string> using namespace std;

void partition(string a[], int l, int r, int &i, int &j) {

i = l-1, j = r; int p = l-1, q = r; string v = a[r]; while (true) {

while (a[++i] < v); while (v < a[--j])

if (j == l) break; if (i >= j) break;

swap(a[i], a[j]); if (a[i] == v)

{

p++;

swap(a[p], a[i]); }

if (a[j] == v) { q--; swap(a[j], a[q]); } } swap(a[i], a[r]); j = i-1;

int k=l; while (k < p)

{

swap(a[k], a[j]); j--;

k++; }

i = i+1; while( k > q) { swap(a[i], a[k]); int k=r-1; i++; k--; } }

(5)

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

if (r <= l) return; int i, j;

partition(a, l, r, i, j); // Recursion

quicksort(a, l, j); quicksort(a, i, r); } int main() { vector<string> data; string tempp; char temppp[6]; int n=0; ifstream ambil; ofstream out_stream;

srand(time(0));// running time double start=clock();

out_stream.open("hasil_3wayquick.txt"); ambil.open("data.txt");

while(!ambil.eof()) //ambil data ke array { getline(ambil, tempp); strcpy(temppp,tempp.c_str()); data.push_back (temppp); } ambil.close(); string a[data.size()];

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

{

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);

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

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

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

getch(); }

(6)

// C++ program for radixsort #include<conio.h> #include<iostream> #include<fstream> #include<vector> #include<iomanip> #define SHOWPASS using namespace std;

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) {

int i, b[n], m = kata[0], exp = 1; for (i = 0; i < n; i++)

{

if (kata[i] > m) m = kata[i]; }

while (m / exp > 0) {

int bucket[10] = { 0 }; for (i = 0; i < n; i++)

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

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

kata[i] = b[i]; exp *= 10; } return kata; } int main() { vector<string> data; int i=0; string n; ifstream ambil; ofstream out_stream;

srand(time(0));// running time double start=clock(); out_stream.open("hasil_radix.txt"); ambil.open("data.txt"); while(!ambil.eof()) { getline(ambil, n); data.push_back (n); }

(7)

ambil.close();

string dataa[data.size()];

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

{

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

}

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

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

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

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

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

getch(); }

(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 Bandung.

(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

mengetahui perbedaan running time pada dua mesin yang berbeda jarang digunakan

sebagai perbandingan

Material

Menganalisis

kompleksitas waktu

terhadap pengurutan string 6 karakter Manusia

(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 sehingga solusi yang diberikan lebih efektif.

(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

X File Edit Format View Help

(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

Data Terurut 3 Way QuickSort.txt <<include>>

<<include>>

Data Terurut QuickSort.txt

Data Terurut RadixSort.txt <<extend>>

<<extend>>

(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

2. Run and debug program pengurutan Algoritma QuickSort

3. Run and debug program pengurutan Algoritma 3 Way QuickSort

4. Run and debug program pengurutan Algoritma RadixSort

1. Sistem menampilkan running time proses generated data tersebut

2. Sistem menampilkan running time Algoritma QuickSort tersebut

3. Sistem menampilkan running time Algoritma 3 Way QuickSort tersebut

4. Sistem menampilkan running time Algoritma RadixSort tersebut

Pasca Kondisi Menampilkan hasil pengurutan ketiga algoritma sorting dalam ekstension (.txt)

(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 m=109 t=116 u=117 r=114 r=114 1=049 p=112 z=122 n=110

1. Menentukan pivot

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

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

6. Mengulangi langkah ke-2 dari posisi p+1 dan dari posisi q-1, sampai kedua scanning bertemu ditengah tabel.

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)

8. Mengulangi langkah ke-2 dari posisi p+1 dan dari posisi q-1, sampai kedua scanning bertemu ditengah tabel.

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

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

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

16. Menentukan pivot

A6 A7 A8 A9 A10

114 117 116 122 115 x

17. Melakukan scanning tabel dari kiri ke kanan sampai ditemukan Ap≥x dan scanning tabel dari kanan ke kiri sampai ditemukan Aq≤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

114 115 116 21. Menentukan pivot

A6 A7 A8

114 115 116 x

22. Karena tidak ditemukan syarat Ap≥x dan Aq≤x. Maka, proses partisi kedua bagian pertama selesai.

A6 A7 A8

114 115 116

Hasil partisi kedua bagian kedua:

A9 A10

(31)

23. Menentukan pivot

A9 A10

122 117 x

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

A9 A10

122 117

p x

25. Swap Ap↔ Aq

A9 A10

117 122 x

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).

Berdasarkan Tabel ASCII. Maka: 4=052

s=115

052 115

28. Menentukan pivot

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

n 10 5 3 1

hdc 4 3 2 1

hdc’ 3 2 1 0

hdc’= hdc-1

2hdc’+1 = n

hdc’log 2 + log 1 = log n hdc’=2log n

hdc’= hdc–1 2_{log n = h}

dc–1

hdc=2log n + 1

H = hdc+ hc =2_{log n + 1+1}

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)

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

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 berdasarkan Algoritma 3 Way QuickSort (.txt) juga dapat dilihat pada Gambar 4.8.

(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)

Berdasarkan Tabel ASCII. Maka: 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

Berikut dipaparkan analisis kompleksitas waktu T(n) dan running time (Tabel 4.2) dan grafik running time algoritma 3 Way QuickSort (Gambar 4.10)

hdc

n 10 4 1

hdc 3 2 1

hdc’ 2 1 0

hdc’= hdc-1

3hdc’+1 = n

hdc’log 3 + log 1 = log n hdc’=3_{log n}

hdc’= hdc–1 3_{log n = h}

dc–1

hdc=3log n + 1

H = hdc+ hc–1 =3log n + 1+1–1 =3log n + 1

T(n) = w. H

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

H 110

(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

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

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)

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

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

0 110

-2 112,122

-4 114,114

5 115

6 116

7 117

-9 109,049

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

0 049

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

-3

-4

-5

-6

-7

-8

-9

-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).

Berdasarkan Tabel ASCII. Maka: 4=052

s=115

052 115

7. Data dibagi sesuai digit terkanan 052 115

Kategori Digit Isi

-1

-2 052

-4

-5 115

-7

-8

-9

-8. Hasil pengategorian tersebut lalu digabungkan kembali dengan metode kongkatenasi menjadi:

052 115

9. 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

(48)

052 115

Kategori Digit Isi

-1 115

-3

-4

-5 052

-7

-8

-9

-10. Kemudian dikongkatenasikan kembali menjadi: 115 052

11. Pengategorian kembali berdasar digit yang terkiri, atau yang paling signifikan

115 052

Kategori Digit Isi

0 052

1 115

-3

-4

-5

-6

-7

(49)

-12. Dan kemudian kongkatenasikan kembali, yang merupakan hasil akhir dari pengurutan berdasarkan RadixSort

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

Berikut dipaparkan analisis kompleksitas waktu T(n) dan running time (Tabel 4.3) dan 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

b. Intel Pentium P6300, RAM 3GB, HDD 320 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

b. Intel Pentium P6300, RAM 3GB, HDD 320 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 input operasi perhitungan atau keseluruhan tahapan algoritma sorting tersebut

(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 ialah RadixSort, 3 Way QuickSort, QuickSort.

(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.

Gambar 4.16 Grafik Running Time Seluruh Algoritma pada Intel Pentium P6300, RAM 3GB, HDD 320 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 (satuan waktu milidetik)

1 3 16 58

Percobaan ke 2 (satuan waktu milidetik)

1 2 8 60

Percobaan ke 3 (satuan waktu milidetik)

1 2 11 57

Percobaan ke 4 (satuan waktu milidetik)

1 1 7 55

Percobaan ke 5 (satuan waktu milidetik)

2 2 6 58

b. Algoritma 3 Way QuickSort

n 60 600 6000 60000

Percobaan ke 1 (satuan waktu milidetik)

1 2 7 55

Percobaan ke 2 (satuan waktu milidetik)

2 2 8 56

Percobaan ke 3 (satuan waktu milidetik)

2 2 10 60

Percobaan ke 4 (satuan waktu milidetik)

1 2 7 65

Percobaan ke 5 (satuan waktu milidetik)

(55)

c. Algoritma RadixSort

n 60 600 6000 60000

Percobaan ke 1 (satuan waktu milidetik)

0 1 6 47

Percobaan ke 2 (satuan waktu milidetik)

1 1 6 47

Percobaan ke 3 (satuan waktu milidetik)

1 2 7 48

Percobaan ke 4 (satuan waktu milidetik)

2 4 6 57

Percobaan ke 5 (satuan waktu milidetik)

0 2 6 53

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

a. Algoritma QuickSort

n 60 600 6000 60000

Percobaan ke 1 (satuan waktu milidetik)

0 3 31 120

Percobaan ke 2 (satuan waktu milidetik)

0 2 15 156

Percobaan ke 3 (satuan waktu milidetik)

0 2 31 140

Percobaan ke 4 (satuan waktu milidetik)

0 3 15 120

Percobaan ke 5 (satuan waktu milidetik)

(56)

b. Algoritma 3 Way QuickSort

n 60 600 6000 60000

Percobaan ke 1 (satuan waktu milidetik)

0 3 15 109

Percobaan ke 2 (satuan waktu milidetik)

15 14 15 124

Percobaan ke 3 (satuan waktu milidetik)

0 0 15 109

Percobaan ke 4 (satuan waktu milidetik)

0 0 15 124

Percobaan ke 5 (satuan waktu milidetik)

0 15 15 124

c. Algoritma RadixSort

n 60 600 6000 60000

Percobaan ke 1 (satuan waktu milidetik)

0 2 15 78

Percobaan ke 2 (satuan waktu milidetik)

15 3 15 109

Percobaan ke 3 (satuan waktu milidetik)

0 0 15 78

Percobaan ke 4 (satuan waktu milidetik)

0 2 15 93

Percobaan ke 5 (satuan waktu milidetik)

(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 algoritma QuickSort dan 3 Way QuickSort.

(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 masing-masing algoritma yang berpengaruh pada jumlah data dan jenis data.

(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 data dapat diinisialisasikan atau dibangkitkan dalam algoritma.

(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: 1. Jumlah masukan data untuk suatu algoritma (n).

(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 ukuran masukan n.

(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 apabila urutan yang didapat belum sesuai. Contohnya adalah bubble sort,

(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 terbaik diantara algoritma pengurutan yang lain. Disebut Partition Exchange Sort

(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

2. 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 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)

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

A1 A2 A3 A4 A5 A6 A7 A8

002 235 088 880 028 093 523 153

p x

5. Swap Ap↔ Aq

A1 A2 A3 A4 A5 A6 A7 A8

002 028 088 880 235 093 523 153

p x

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

8. Mengulangi langkah ke-2 dari posisi p+1 dan dari posisi q-1, sampai kedua 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

10. Membagi partisi menjadi 2 tabel: Hasil partisi pertama:

A1 A2 A3 A4 A5

002 028 088 153 093

11. Menentukan pivot

A1 A2 A3 A4 A5

002 028 088 153 093 x

12. 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

002 028 088 153 093 x

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

A1 A2 A3 A4 A5

002 028 088 093 153 x

Hasil partisi kedua:

(69)

14. Menentukan pivot

A6 A7 A8

235 523 880 x

15. Melakukan scanning tabel dari kiri ke kanan sampai ditemukan Ap≥x dan 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.}

Deklarasi : k : integer;

(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 :

Pivot <- A[(i+j) div 2] { pivot = elemen tengah } p <- i

q <- j repeat

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

4. Ulangi langkah pertama hingga keseluruhan data terurut (A1<A2<A3...<An) Sebagai contoh, ambil bilangan yang sama seperti sebelumnya:

(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 : Algoritma :

if (i<j) then

Partisi(a,l,i,j,r) {Ukuran (a) > 1}

ThreeWayQuickSort(a,l,j) ThreeWayQuickSort(a,i, r) end if

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

if i<pivot then swap [lt],a[i] temp <- a[i] a[i] <- [lt] a[lt] <- temp lt<- lt+1 i<- i+1

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

endwhile endif

if i>pivot then swap a[i],[gt] temp <- a[i] a[i] <- [gt]

(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 :

Pivot <- A[(i+j) div 2] { pivot = elemen tengah } p <- i

q <- j repeat

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 pengurutan bilangan desimal dan bilangan bit.[8]

(75)

2.8.1. Langkah-langkah melakukan pengurutan algoritma RadixSort Langkah-langkah pengurutan RadixSort adalah sebagai berikut:

1. Data dibagi sesuai digit terkanan

523 235 088 880 028 093 002 153

Kategori Digit Isi

0 880

-2 002

3 523, 093, 153

-5 235

-7

-8 088, 028

-2. Hasil pengategorian tersebut lalu digabungkan kembali dengan metode kongkatenasi menjadi:

880 002 523 093 153 235 088 028

3. Kemudian pengategorian dilakukan kembali, namun kali ini berdasar digit 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

-5 153

-7

-8 880, 088

9 093

4. Kemudian dikongkatenasikan kembali menjadi:

002 523 028 235 153 880 088 093

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

002 523 028 235 153 880 088 093

Kategori Digit Isi

0 002, 028, 088, 093

1 153

2 235

-4

-5 523

-7

-8 880

-6. Dan kemudian kongkatenasikan kembali, yang merupakan hasil akhir dari pengurutan berdasarkan RadixSort

(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

{--- salin A ke B ---} fori:=1 ton do

B[i] := A[i]; pembagi := 1; endfor

for x:=1 tod do 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;

{--- dikonkat ---} ctr := 0;

endfor

for i:=0 to 9 do begin

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

(78)

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

end; end;

pembagi := pembagi * 10; end;

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 (QuickSort dan RadixSort) terhadap penelitian penulis.

(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. b. Intel Pentium P6300, RAM 3GB, HDD 320 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 Way QuickSort, dan RadixSort dalam mengurutkan string yang dibangkitkan.

(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 ini.

(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 waktu, running time.

(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, running time .

(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,

Dr. Poltak Sihombing, M.Kom NIP. 196203171991031011

(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

PLOREN PERONICA PASARIBU 131421038

(89)

Segala puji dan syukur penulis panjatkan ke hadirat Tuhan Yang Maha Esa, karena atas limpahan berkat dan karunia-Nya penulis mampu menyelesaikan skripsi ini sebagai syarat untuk memperoleh gelar Sarjana Komputer, Program Studi Ilmu Komputer, Fakultas Ilmu Komputer dan Teknologi Informasi Universitas Sumatera Utara.

Pada pengerjaan skripsi dengan judul Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort, penulis menyampaikan terima kasih dan penghargaan yang sebesar-besarnya kepada semua pihak yang telah memberikan bimbingan dan dukungan, baik secara materil dan moril, terutama kepada:

1. Bapak Prof. Dr. Runtung Sitepu S.H, M.Hum, selaku Rektor Universitas Sumatera Utara.

2. Bapak Prof. Dr. Opim Salim Sitompul, M.Si., selaku Dekan Fakultas Ilmu Komputer dan Teknologi Informasi Universitas Sumatera Utara.

3. Bapak Dr. Poltak Sihombing, M.Kom, selaku Ketua Program Studi Ilmu Komputer, Fakultas Ilmu Komputer dan Teknologi Informasi Universitas Sumetera Utara, dan juga sebagai dosen penguji yang telah memberikan saran dan kritikan yang sangat berguna bagi penulis.

4. Ibu Maya Silvi Lydia, B.Sc., M.Sc selaku Sekretaris Program Studi S1 Ilmu Komputer, Fakultas Ilmu Komputer dan Teknologi Informasi Universitas Sumatera Utara.

5. Bapak James Piter Marbun, M.Kom dan Bapak Amer Sharif, S.Si, M.Kom selaku pembimbing yang telah banyak meluangkan waktunya dalam memberikan masukan-masukan, baik kritik dan saran kepada penulis selama pembuatan sampai penyelesaian skripsi ini.

6. Bapak Drs. Marihat Situmorang, M.Kom dan Bapak Jos Timanta Tarigan, S.Kom, M.Sc sebagai dosen penguji yang telah memberikan saran dan kritikan

(90)

banyak masukan serta dukungan kepada penulis selama di bangku perkuliahan sampai penyelesaian skripsi ini.

8. Seluruh dosen serta pegawai di Program Studi S1 Ilmu Komputer Departemen Ilmu Komputer, Fakultas Ilmu Komputer dan Teknologi Informasi, Universitas Sumatera Utara.

9. Teristimewa kepada kedua orang tua penulis yang tercinta Ayahanda (S. Pasaribu), Ibunda (R. Hutabarat), serta adik-adik penulis (Stephani dan Holly) yang senantiasa memberikan kasih sayang, doa, dukungan dan motivasi yang tak terhingga dan tak ternilai harganya.

10. Seluruh teman mahasiswa Ekstensi S1 Ilmu Komputer Stambuk 2013 khususnya KOM B’2013 yang selama ini telah menjadi keluarga dan sahabat penulis, teristimewa kepada Kak Winda, Adik Felix, Chitra, Kak Rofika, Farid, Bang Rony, Winda Samosir, Lulu, dan Asrul.

Dalam skripsi ini, penulis menyadari masih terdapat kekurangan dan masih jauh dari sempurna. Oleh karena itu, dengan segala kerendahan hati penulis mengharapkan kritik dan saran yang bersifat membangun demi perbaikan dan penyempurnaan skripsi ini. Akhir kata, semoga skripsi ini bermanfaat bagi semua pihak yang membacanya.

Medan, Agustus 2016

(1)

ABSTRAK

Kata Kunci : Pengurutan, QuickSort, 3 Way QuickSort, RadixSort, kompleksitas waktu, running time.

(2)

ANALYSIS COMPARISON QUICKSORT, 3 WAY QUICKSORT, AND RADIXSORT ALGORITHM

ABSTRACT

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

(3)

DAFTAR ISI

Halaman

Halaman Judul i

Halaman Persetujuan ii

Halaman Pernyataan iii

Halaman Penghargaan iv

Halaman Abstrak vi

Halaman Abstract vii

Halaman Daftar Isi viii

Halaman Daftar Gambar x

Halaman Daftar Tabel xi

BAB 1 PENDAHULUAN

1.1 Latar Belakang 1

1.2 Rumusan Masalah 2

1.3 Batasan Masalah 2

1.4 Tujuan Penelitian 3

1.5 Manfaat Penelitian 3

1.6 Metodologi Penelitian 3

1.7 Sistematika Penulisan 4

BAB 2 LANDASAN TEORI

2.1 Algoritma 5

2.2 Kompleksitas Algoritma 6

2.2.1 Kompleksitas Waktu 6

2.2.2 Kompleksitas Waktu Asimptotik 7

2.2.3 Kompleksitas Ruang 8

2.3 Running Time 9

2.4 Pengurutan 9

2.5 Klasifikasi Algoritma Pengurutan 9

2.6 Algoritma QuickSort 10

2.6.1 Langkah-langkah Melakukan Pengurutan Algoritma QuickSort 11

2.6.2 Pseudocode Algoritma QuickSort 14

2.6.3 Kompleksitas Waktu Asimptotik Algoritma QuickSort 16

2.7 Algoritma 3 Way QuickSort 16

(4)

BAB 3 ANALISIS DAN PERANCANGAN SISTEM

3.1 Analisis Masalah 24

3.2 Analisis Kebutuhan Sistem 25

3.2.1 Kebutuhan Fungsional 25

3.2.2 Kebutuhan Non-Fungsional 25

3.3 Analisis Proses 26

3.4 Pemodelan Sistem 28

3.4.1 Use Case Diagram 28

3.4.2 Activity Diagram 29

3.4.3 Sequence Diagram 31

3.5 Flowchart Sistem 31

3.5.1 Flowchart Algoritma Quicksort 32

3.5.2 Flowchart Algoritma 3 Way Quicksort 33

3.5.3 Flowchart Algoritma Radixsort 34

BAB 4 IMPLEMENTASI SISTEM

4.1 Implementasi Sistem 35

4.2 Generated Data 35

4.3 Algoritma Quicksort 37

4.3.1 Analisis Algoritma QuickSort 39

4.3.2 Analisis Kompleksitas Waktu (Tn) dan Grafik Perbandingan 47 Algoritma QuickSort

4.4 Algoritma 3 Way Quicksort 49

4.4.1 Analisis Algoritma 3 Way QuickSort 51

4.4.2 Analisis Kompleksitas Waktu (Tn) dan Grafik Perbandingan 54 Algoritma 3 Way QuickSort

4.5 Algoritma Radixsort 56

4.5.1 Analisis Algoritma RadixSort 58

4.5.2 Analisis Kompleksitas Waktu (Tn) dan Grafik Perbandingan 63 Algoritma RadixSort

4.6 Kesimpulan Analisis Keseluruhan Algoritma 64

BAB 5 PENUTUP

5.1 Kesimpulan 71

5.2 Saran 72

DAFTAR PUSTAKA

(5)

DAFTAR GAMBAR

Halaman

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

Gambar 3.1 Diagram Ishikawa 24

Gambar 3.2 Data Acak 26

Gambar 3.3 Tabel ASCII 27

Gambar 3.4 Use Case Diagram Sistem 28

Gambar 3.5 Activity Diagram Sistem 29

Gambar 3.6 Sequence Diagram Sistem 31

Gambar 3.7 Flowchart Algoritma QuickSort 32

Gambar 3.8 Flowchart Algoritma 3 Way QuickSort 33

Gambar 3.9 Flowchart Algoritma RadixSort 34

Gambar 4.1 Tampilan Compile Generated Data 35

Gambar 4.2 Tampilan Hasil Generated Data 36

Gambar 4.3 Tampilan Compile Algoritma QuickSort 37

Gambar 4.4 Tampilan Hasil Algoritma QuickSort 38

Gambar 4.5 Hasil Pengurutan Algoritma QuickSort 46

Gambar 4.6 Grafik Running Time Perbandingan Algoritma QuickSort 49 Gambar 4.7 Tampilan Compile Algoritma 3 Way QuickSort 49 Gambar 4.8 Tampilan Hasil Algoritma 3 Way QuickSort 50 Gambar 4.9 Hasil Pengurutan Algoritma 3 Way QuickSort 53 Gambar 4.10 Grafik Running Time Perbandingan Algoritma 56

3 Way QuickSort

Gambar 4.11 Tampilan Compile Algoritma RadixSort 56

Gambar 4.12 Tampilan Hasil Algoritma RadixSort 57

Gambar 4.13 Hasil Pengurutan Algoritma RadixSort 62 Gambar 4.14 Grafik Running Time Perbandingan Algoritma RadixSort 64 Gambar 4.15 Grafik Running Time Seluruh Algoritma pada Intel Core I5 66

2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB

Gambar 4.16 Grafik Running Time Seluruh Algoritma pada Intel Pentium 66 P6300, RAM 3GB, HDD 320 GB

(6)

DAFTAR TABEL

Halaman

Tabel 2.1 Pengelompokan algoritma berdasarkan notasi O-Besar 7

Tabel 3.1 Activity Diagram Sistem 30

Tabel 4.1 Running Time Perbandingan Algoritma QuickSort 48 Tabel 4.2 Running Time Perbandingan Algoritma 3 Way QuickSort 55 Tabel 4.3 Running Time Perbandingan Algoritma RadixSort 63 Tabel 4.4 Running Time Seluruh Algoritma pada Intel Core I5 67

2520m 2,50 GHz 3MB Cache, RAM 2 GB, HDD 500 GB

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

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

`

:

Parts

Dokumen yang terkait

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Dukungan

Links

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

`

:

Parts

Dokumen yang terkait

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Analisis Perbandingan Algoritma QuickSort, 3 Way QuickSort, dan RadixSort

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Otomatisasi Indeks Ebook Algorithms Dengan Menggunakan Algoritma Knuth-Morris- Pratt Dan Algoritma Quicksort

Dokumen yang Anda mencari sudah siap untuk unduhkan