Implementasi dan Analisis Algoritma Bucket Sort, Strand Sort dan Quick Sort 2 Pivot Dalam Pensortiran Data yang Berjumlah Banyak

(1)

LISTING PROGRAM using System; using System.Collections.Generic; using System.Linq; using System.Windows.Forms; namespace SortingApplication {

static class Program {

/// <summary>

/// The main entry point for the application. /// </summary>

[STAThread]

static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new FormAplikasiSorting()); } } } using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SortingApplication { class BucketSort {

public static void bsort3(int[] integers) {

//Verify input

if (integers == null || integers.Length == 0) return;

//Find the maximum and minimum values in the array int maxValue = integers[0]; //start with first element int minValue = integers[0];

//Note: start from index 1

for (int i = 1; i < integers.Length; i++) {

if (integers[i] > maxValue) maxValue = integers[i]; if (integers[i] < minValue) minValue = integers[i]; }

//Create a temporary "bucket" to store the values in order //each value will be stored in its corresponding index //scooting everything over to the left as much as possible (minValue)

//e.g. 34 => index at 34 - minValue

List<int>[] bucket = new List<int>[maxValue - minValue + 1]; //Initialize the bucket

for (int i = 0; i < bucket.Length; i++) {

(2)

}

//Move items to bucket

for (int i = 0; i < integers.Length; i++) {

bucket[integers[i] - minValue].Add(integers[i]); }

//Move items in the bucket back to the original array in order int k = 0; //index for original array

for (int i = 0; i < bucket.Length; i++) {

if (bucket[i].Count > 0) {

for (int j = 0; j < bucket[i].Count; j++) {

integers[k] = bucket[i][j]; k++; } } } } } } using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SortingApplication { class StrandSort {

public int[] Sort(int[] data){ int[] arr = data;

for (int i = 1; i < arr.Length; i++) {

int j = i - 1; int index = -1;

while (arr[i] < arr[j]) { index = j;

j--; if (j < 0) break; }

if(index == -1) continue; int temp = arr[i];

for (int k = i; k > index; k--) { arr[k] = arr[k - 1];

}

(3)

namespace SortingApplication {

class QuickSortDualPivot {

public int[] sort(int[] input) {

int[] data = input;

sort(data, 0, data.Length - 1); return data;

}

private void sort(int[] input, int lowIndex, int highIndex) {

if (highIndex <= lowIndex) return; int pivot1 = input[lowIndex]; int pivot2 = input[highIndex]; if (pivot1 > pivot2)

{

exchange(input, lowIndex, highIndex); pivot1 = input[lowIndex];

pivot2 = input[highIndex];

//sort(input, lowIndex, highIndex); }

else if (pivot1 == pivot2) {

int swapIndex = lowIndex;

while (pivot1 == pivot2 && swapIndex <= highIndex) {

swapIndex++;

exchange(input, swapIndex, highIndex); pivot2 = input[highIndex];

}

if (pivot1 > pivot2) {

exchange(input, lowIndex, highIndex); pivot1 = input[lowIndex];

pivot2 = input[highIndex];

//sort(input, lowIndex, highIndex); }

}

int i = lowIndex + 1; int lt = lowIndex + 1; int gt = highIndex - 1; while (i <= gt)

{

if (less(input[i], pivot1)) {

exchange(input, i++, lt++); }

else if (less(pivot2, input[i])) {

(4)

exchange(input, lowIndex, --lt); exchange(input, highIndex, ++gt); sort(input, lowIndex, lt - 1);

//if (less (input[lt], input[gt])) sort (input, lt+1, gt-1); sort(input, lt + 1, gt - 1);

sort(input, gt + 1, highIndex); }

public bool less(int a, int b) {

return a < b; }

public void exchange(int[] input, int i, int r) {

if (i >= input.Length) return;

if (input[i] == null) {

int temp = input[i]; input[i] = input[r]; input[r] = temp; }

else {

int temp = input[i]; input[i] = input[r]; input[r] = temp; } } } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Diagnostics; using System.Threading; using System.Windows.Forms.DataVisualization.Charting; namespace SortingApplication {

public partial class FormAplikasiSorting : Form {

int[] data,data2,data3,strand,quick,bucket; int n, nilaimaks;

Random r = new Random();

ProgressDialog progressWindow; ToolTip tooltip = new ToolTip(); Point? prevPosition = null; public FormAplikasiSorting() {

InitializeComponent();

// Console.WriteLine("Bucket Sort");

// int[] sortBucket = new BucketSort().sort(data); // printArray(sortBucket);

(5)

public void printArray(int[] input) { for (int i = 0; i < input.Length; i++) {

Console.Write(input[i] + ", "); }

Console.WriteLine(); }

private void button1_Click(object sender, EventArgs e) {

richTextBox1.Text = null; richTextBox2.Text = null; richTextBox3.Text = null;

Thread thread = new Thread(new ThreadStart(GenerateData)); progressWindow = new ProgressDialog();

progressWindow.SetTitle("Generating random data"); progressWindow.SetLabelMessage("generating..."); thread.Start();

progressWindow.ShowDialog(); }

private void GenerateData() {

StringBuilder sb = new StringBuilder(); n = Convert.ToInt32(maxitem.Text);

nilaimaks = Convert.ToInt32(maxitemvalue.Text); data = new int[n];

data2 = new int[n]; data3 = new int[n];

for (int i = 0; i < n; i++) {

int j = r.Next(1, nilaimaks); data[i] = j;

data2[i] = j; data3[i] = j; sb.Append(j); if (i != n - 1) sb.Append(", "); }

progressWindow.SetLabelMessage("displaying data ..."); this.BeginInvoke(new Action(() => {

richTextBox1.Text = sb.ToString(); }));

this.BeginInvoke(new Action(() => {

// Close the dialog if it hasn't been already if (progressWindow.InvokeRequired)

progressWindow.BeginInvoke(new Action(() => progressWindow.Close()));

}

void Button2Click(object sender, EventArgs e) {

(6)

Thread thread = new Thread(new ThreadStart(Sort)); progressWindow = new ProgressDialog();

progressWindow.SetTitle("Sorting Data"); progressWindow.SetLabelMessage("sorting ..."); progressWindow.SetIndeterminate(true); thread.Start(); progressWindow.ShowDialog(); }

private void Sort() {

//chart1.Series.Clear();

//while(chart1.Series.Count > 0) //{

// foreach (var series in chart1.Series) // {

// series.Points.Clear(); // }

// MessageBox.Show("ada"); //}

StringBuilder sb1 = new StringBuilder(); StringBuilder sb2 = new StringBuilder(); StringBuilder sb3 = new StringBuilder(); decimal rtmQuick = 0;

decimal rtmStrand = 0; decimal rtmBucket = 0;

Stopwatch watch1 = new Stopwatch();// running time Stopwatch watch2 = new Stopwatch();// running time Stopwatch watch3 = new Stopwatch();// running time progressWindow.SetLabelMessage("sorting using QuickSortDualPivot");

watch1 = Stopwatch.StartNew(); watch1.Restart();

quick = new QuickSortDualPivot().sort(data); watch1.Stop();

rtmQuick =

Math.Round(Convert.ToDecimal(watch1.Elapsed.TotalMilliseconds * 1000), 4); textBox9.Text = rtmQuick.ToString();

}));

progressWindow.SetLabelMessage("sorting using StrandSort"); watch2 = Stopwatch.StartNew();

watch2.Restart();

strand = new StrandSort().Sort(data2); watch2.Stop();

rtmStrand =

Math.Round(Convert.ToDecimal(watch2.Elapsed.TotalMilliseconds * 1000), 4); textBox10.Text = rtmStrand.ToString();

}));

progressWindow.SetLabelMessage("sorting using BucketSort"); watch3 = Stopwatch.StartNew();

watch3.Restart(); bucket = data3;

BucketSort.bsort3(bucket); watch3.Stop();

rtmBucket =

(7)

}));

for (int i = 0; i < n; i++) {

sb1.Append(data[i].ToString()); sb2.Append(data2[i].ToString()); sb3.Append(data3[i].ToString()); if (i != n - 1)

{ sb1.Append(", "); sb2.Append(", "); sb3.Append(", "); } }

this.BeginInvoke(new Action(() => { txtStrandSort.Text += sb2.ToString(); txtBucketSort.Text += sb3.ToString(); txtQuickSort.Text += sb1.ToString(); foreach (var series in chart1.Series) {

series.Points.Clear(); }

chart1.Series[0].Points.AddXY("Bucket Sort", rtmBucket); chart1.Series[0].Points.AddXY("Strand Sort", rtmStrand); chart1.Series[0].Points.AddXY("Quick Sort 2 Pivot", rtmQuick);

}));

// Close the dialog if it hasn't been already if (progressWindow.InvokeRequired)

progressWindow.BeginInvoke(new Action(() => progressWindow.Close()));

}

private void FormAplikasiSorting_Load(object sender, EventArgs e) { } } } using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace SortingApplication {

public partial class ProgressDialog : Form { public ProgressDialog() { InitializeComponent(); SetIndeterminate(true); }

public void UpdateProgress(int progress) {

if (progressBar.InvokeRequired)

(8)

else

progressBar.Value = progress; }

public void SetLabelMessage(string text) {

progressBar.BeginInvoke(new Action(() => lblText.Text = text));

else

lblText.Text = text; }

public void SetTitle(string text) {

progressBar.BeginInvoke(new Action(() => this.Text = text)); else

this.Text = text; }

public void SetIndeterminate(bool isIndeterminate) {

if (progressBar.InvokeRequired) {

progressBar.BeginInvoke(new Action(() => {

if (isIndeterminate)

progressBar.Style = ProgressBarStyle.Marquee; else

progressBar.Style = ProgressBarStyle.Blocks; } )); } else { if (isIndeterminate)

progressBar.Style = ProgressBarStyle.Marquee; else

progressBar.Style = ProgressBarStyle.Blocks; }

}

private void ProgressDialog_Load(object sender, EventArgs e) { } } } namespace SortingApplication {

partial class FormAplikasiSorting {

/// <summary>

/// Required designer variable. /// </summary>

private System.ComponentModel.IContainer components = null; /// <summary>

/// Clean up any resources being used. /// </summary>

/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>

protected override void Dispose(bool disposing) {

(9)

{

components.Dispose(); }

base.Dispose(disposing); }

#region Windows Form Designer generated code /// <summary>

/// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary>

private void InitializeComponent() {

System.Windows.Forms.DataVisualization.Charting.ChartArea

chartArea2 = new System.Windows.Forms.DataVisualization.Charting.ChartArea(); System.Windows.Forms.DataVisualization.Charting.Legend legend2 = new System.Windows.Forms.DataVisualization.Charting.Legend();

System.Windows.Forms.DataVisualization.Charting.Series series2 = new System.Windows.Forms.DataVisualization.Charting.Series();

this.label1 = new System.Windows.Forms.Label(); this.label2 = new System.Windows.Forms.Label(); this.maxitem = new System.Windows.Forms.TextBox(); this.maxitemvalue = new System.Windows.Forms.TextBox(); this.button1 = new System.Windows.Forms.Button(); this.label3 = new System.Windows.Forms.Label(); this.label4 = new System.Windows.Forms.Label(); this.label5 = new System.Windows.Forms.Label(); this.label6 = new System.Windows.Forms.Label(); this.label7 = new System.Windows.Forms.Label(); this.label8 = new System.Windows.Forms.Label(); this.label9 = new System.Windows.Forms.Label(); this.label10 = new System.Windows.Forms.Label(); this.label11 = new System.Windows.Forms.Label(); this.textBox9 = new System.Windows.Forms.TextBox(); this.textBox10 = new System.Windows.Forms.TextBox(); this.textBox11 = new System.Windows.Forms.TextBox(); this.button2 = new System.Windows.Forms.Button();

this.richTextBox1 = new System.Windows.Forms.RichTextBox(); this.richTextBox2 = new System.Windows.Forms.RichTextBox(); this.richTextBox3 = new System.Windows.Forms.RichTextBox(); this.txtBucketSort = new System.Windows.Forms.RichTextBox(); this.txtStrandSort = new System.Windows.Forms.RichTextBox(); this.txtQuickSort = new System.Windows.Forms.RichTextBox(); this.chart1 = new

System.Windows.Forms.DataVisualization.Charting.Chart(); this.label12 = new System.Windows.Forms.Label(); this.label13 = new System.Windows.Forms.Label(); ((System.ComponentModel.ISupportInitialize)(this.chart1)).BeginInit(); this.SuspendLayout(); // // label1 //

this.label1.AutoSize = true;

this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 9F, System.Drawing.FontStyle.Regular,

System.Drawing.GraphicsUnit.Point, ((byte)(0)));

this.label1.Location = new System.Drawing.Point(22, 51); this.label1.Name = "label1";

this.label1.Size = new System.Drawing.Size(97, 15); this.label1.TabIndex = 0;

this.label1.Text = "Max Item "; //

// label2 //

(10)

this.label2.Font = new System.Drawing.Font("Microsoft Sans Serif", 9F, System.Drawing.FontStyle.Regular,

this.label2.Text = "Max Item Value"; //

// maxitem //

this.maxitem.Location = new System.Drawing.Point(125, 51); this.maxitem.Name = "maxitem";

this.maxitem.Size = new System.Drawing.Size(96, 20); this.maxitem.TabIndex = 2;

this.maxitem.Text = "1000"; //

// maxitemvalue //

this.maxitemvalue.Location = new System.Drawing.Point(125, 75); this.maxitemvalue.Name = "maxitemvalue";

this.maxitemvalue.Size = new System.Drawing.Size(96, 20); this.maxitemvalue.TabIndex = 3;

this.maxitemvalue.Text = "1000"; //

// button1 //

this.button1.Location = new System.Drawing.Point(257, 71); this.button1.Name = "button1";

this.button1.Size = new System.Drawing.Size(75, 23); this.button1.TabIndex = 5;

this.button1.Text = "Data Acak";

this.button1.UseVisualStyleBackColor = true; this.button1.Click += new

System.EventHandler(this.button1_Click); //

// label3 //

this.label3.Text = "Bucket Sort"; //

// label4 //

this.label4.Text = "Strand Sort"; //

// label5 //

this.label5.Text = "Quick Sort 2 Pivot"; //

// label6 //

(11)

this.label6.Name = "label6";

this.label6.Text = "Hasil Sorting Bucket Sort"; //

// label7 //

this.label7.Text = "Hasil Sorting Strand Sort"; //

// label8 //

this.label8.Text = "Hasil Sorting Quick Sort 2 Pivot"; //

// label9 //

this.label9.Text = "Running Time"; //

// label10 //

// label11 //

// textBox9 //

this.textBox9.Location = new System.Drawing.Point(471, 522); this.textBox9.Name = "textBox9";

this.textBox9.Size = new System.Drawing.Size(96, 20); this.textBox9.TabIndex = 21;

//

// textBox10 //

this.textBox10.Location = new System.Drawing.Point(244, 522); this.textBox10.Name = "textBox10";

//

// textBox11 //

(12)

this.textBox11.Name = "textBox11";

//

// button2 //

this.button2.Location = new System.Drawing.Point(348, 71); this.button2.Name = "button2";

this.button2.Size = new System.Drawing.Size(75, 23); this.button2.TabIndex = 24;

this.button2.Text = "Sorting";

this.button2.UseVisualStyleBackColor = true;

this.button2.Click += new System.EventHandler(this.Button2Click); //

// richTextBox1 //

this.richTextBox1.Location = new System.Drawing.Point(22, 120); this.richTextBox1.Name = "richTextBox1";

this.richTextBox1.Size = new System.Drawing.Size(196, 173); this.richTextBox1.TabIndex = 25;

this.richTextBox1.Text = ""; //

// richTextBox2 //

// richTextBox3 //

// txtBucketSort //

this.txtBucketSort.Location = new System.Drawing.Point(22, 326); this.txtBucketSort.Name = "txtBucketSort";

this.txtBucketSort.Size = new System.Drawing.Size(196, 173); this.txtBucketSort.TabIndex = 28;

this.txtBucketSort.Text = ""; //

// txtStrandSort //

this.txtStrandSort.Location = new System.Drawing.Point(244, 326); this.txtStrandSort.Name = "txtStrandSort";

this.txtStrandSort.Size = new System.Drawing.Size(196, 173); this.txtStrandSort.TabIndex = 29;

this.txtStrandSort.Text = ""; //

// txtQuickSort //

this.txtQuickSort.Location = new System.Drawing.Point(471, 326); this.txtQuickSort.Name = "txtQuickSort";

this.txtQuickSort.Size = new System.Drawing.Size(196, 173); this.txtQuickSort.TabIndex = 30;

this.txtQuickSort.Text = ""; //

// chart1 //

chartArea2.Name = "ChartArea1";

(13)

this.chart1.Legends.Add(legend2);

this.chart1.Location = new System.Drawing.Point(78, 551); this.chart1.Name = "chart1";

series2.ChartArea = "ChartArea1"; series2.Legend = "Legend1";

series2.LegendText = "Running Time"; series2.Name = "Series1";

this.chart1.Series.Add(series2);

this.chart1.Size = new System.Drawing.Size(545, 155); this.chart1.TabIndex = 31;

this.chart1.Text = "chart1"; //

// label12 //

this.label12.Font = new System.Drawing.Font("MS Reference Sans Serif", 8.25F, System.Drawing.FontStyle.Bold,

this.label12.Text = "IMPLEMENTASI DAN ANALISIS ALGORITMA BUCKET SORT, STRAND SORT DAN QUICK SORT 2 PIV" +

"OT"; //

// label13 //

this.label13.Font = new System.Drawing.Font("MS Reference Sans Serif", 8.25F, System.Drawing.FontStyle.Bold,

this.label13.Text = "DALAM PENSORTIRAN DATA YANG BERJUMLAH BANYAK";

//

// FormAplikasiSorting //

this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(708, 702);

(14)

this.Controls.Add(this.maxitemvalue); this.Controls.Add(this.maxitem); this.Controls.Add(this.label2); this.Controls.Add(this.label1); this.Name = "FormAplikasiSorting"; this.StartPosition =

System.Windows.Forms.FormStartPosition.CenterScreen; this.Text = "Aplikasi Sorting Data"; this.Load += new

System.EventHandler(this.FormAplikasiSorting_Load);

((System.ComponentModel.ISupportInitialize)(this.chart1)).EndInit(); this.ResumeLayout(false);

this.PerformLayout(); }

private System.Windows.Forms.RichTextBox txtQuickSort; private System.Windows.Forms.RichTextBox txtStrandSort; private System.Windows.Forms.RichTextBox txtBucketSort; private System.Windows.Forms.RichTextBox richTextBox3; private System.Windows.Forms.RichTextBox richTextBox2; private System.Windows.Forms.RichTextBox richTextBox1; #endregion

private System.Windows.Forms.Label label1; private System.Windows.Forms.Label label2; private System.Windows.Forms.TextBox maxitem; private System.Windows.Forms.TextBox maxitemvalue; private System.Windows.Forms.Button button1; private System.Windows.Forms.Label label3; private System.Windows.Forms.Label label4; private System.Windows.Forms.Label label5; private System.Windows.Forms.Label label6; private System.Windows.Forms.Label label7; private System.Windows.Forms.Label label8; private System.Windows.Forms.Label label9; private System.Windows.Forms.Label label10; private System.Windows.Forms.Label label11; private System.Windows.Forms.TextBox textBox9; private System.Windows.Forms.TextBox textBox10; private System.Windows.Forms.TextBox textBox11; private System.Windows.Forms.Button button2;

private System.Windows.Forms.DataVisualization.Charting.Chart chart1; private System.Windows.Forms.Label label12;

private System.Windows.Forms.Label label13; }

(15)

DAFTAR PUSTAKA

Wilkinson, Barry dan Michael Allen. 2010. Tehcniques and Apllications Using Networked and Parallel Computers. Second editons :Terjemahan. Andi: Yogyakarta.

M. Shalahuddin, Rosa A.S. 2010. Modul Pembelajaran Algoritma dan Pemrograman . University of Houston,Texas, U.S.A.

Suryani, E.2006. Pemodelan dan Simulasi. Yogyakarta: Graha Ilmu.

Drozdek, A.2001. Data Structures and Algorithms in C++. Brooks/Cole Thomson Learning. California.USA.

Jon L. Bentley, M. Douglas mcllroy.1993. Engineering a Sort Function.Software-Practice and Experience, Vol 23(11).

Knuth, D.1998. The Art of Computer programing Sorting and Searching, 2nd edition. Vol 3. Addison-Wesley.

A. Aho, J. Hoperoft, J.Ullman.2000. “Data Structures and Algoritms”, Pearson India reprint

Fanani Ikhsan. 2011. Penggunaan ”Big O Notation” untuk Menganalisa Efisiensi Algoritma. Program Studi Teknik Informatika, Institut Teknologi Bandung.

Leiss Ernst L, 2007. A ProgrAmmer’s ComPAnionto Algorithm AnAlysis, University of Houston,Texas, U.S.A.

Mansi Rami. 2010.“Enhanced Quicksort Algorithm.” The International Arab Journal of Information Technology, Vol. 7, No. 2.

Munir Rinaldi, 2007, Algoritma dan Pemrograman, Informatika Bandung. Nugroho Andi, 2005, Pemrograman Berorientasi Objek, Informatika Bandung.

Triono Puji. 2010. Analisis Perbandingan Algoritma Sorting dan Searching. Yogyakarta: Fakultas Teknologi Industri Universitas Ahmad Dahlan.

(16)

BAB 3

ANALISIS DAN PERANCANGAN SISTEM

3.1 Analisis Sistem

Analisis sistem merupakan tahap awal dalam sebuah penelitian yang bertujuan untuk mengetahui masalah terkait dalam pembuatan sebuah sistem dan menggambarkan proses-proses yang ada di dalam sistem untuk menghasilkan keluaran yang sesuai dengan kebutuhan pemakai (user).

3.1.1 Analisis Masalah

Masalah ataupun problema yang diangkat dalam penelitian ini adalah bagaimana menganalisis kompleksitas waktu (Big O) dengan menggunakan algoritma Bucket Sort, Strand Sort dan Quick Sort 2 Pivot.

Diagram Ishikawa (fishbone diagram) biasanya disebut juga diagram sebab akibat yang biasanya digunakan untuk mengidentifikasi masalah yang ada pada sistem yang akan dirancang. Dengan diagram ini kita dapat mengidentifikasi, mengeksplorasi dan menggambarkan suatu masalah dengan mengikutsertakan sebab dan akibat dari permasalahan dalam visual grafis. Dengan demikian proses pencapaian sistem akan sangat dibantu dengan adanya Diagram Ishikawa ini.

(17)

3.2 Analisis Kebutuhan Sistem

Untuk membanngun sebuah sistem, sangat 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-batasan yang lainnya (optional).

3.2.1 Kebutuhan Fungsional

Kebutuhan fungsional merupakan deskripsi dari aktifitas dan layanan yang sistem harus berikan. Hal yang menjadi kebutuhan fungsional dalam pengurutan data acak ini adalah:

1. Sistem yang mampu mengurutkan data acak berupa data Integer.

2. Sistem harus mampu menghitung Running Time dan menganalisis Kompleksitas waktu dari algoritma Bucket Sort, Strand Sort dan Quick Sort 2 Pivot.

3.2.2 Kebutuhan Non-fungsional

1. Mudah Digunakan (User Friendly)

Sistem yang akan dibangun harus User Friendly, artinya bahwa sistem mudah digunakan dan dipahami user.

2. Menjadi referensi

Sistem yang akan dibangun diharapkan mampu menjadi referensi bagi user untuk menganalisis Kompleksitas pengurutan data yang acak.

3. Pelayanan

(18)

3.3 Analisis proses

Dalam sistem ini terdapat dua proses utama, yaitu Proses pengurutan data dan Kompleksitas waktu berdasarkan algoritma Bucket Sort, Strand Sort dan Quick Sort 2 Pivot dalam mengurutkan data Integer.

Gambar 3.2 Bentuk dari hasil Sorting Data

3.4 Pemodelan Sistem

Pemodelan sistem yang dirancang bertujuan untuk menggambarkan peran user (pengguna) terhadap sistem yang dibuat. Pemodelan sistem yang digunakan dalam merancang sistem ini yaitu Use-case diagram, activity diagram dan sequence diagram.

Max Item

Max Item Value

Proses Pengurutan Data

Data Acak Sorting

Bucket Sort Strand Sort Quick Sort 2 Pivot

Hasil Sorting Bucket Sort

Hasil Sorting Strand Sort

Hasil Sorting Quick Sort 2 Pivot

(19)

3.4.1 Use-case Diagram

Diagram ini memperlihatkan himpunan use-case dan aktor-aktor (suatu jenis dari kelas). Diagram ini sangatlah penting dan yang paling utama untuk memodelkan sistem yang dubutuhkan oleh pengguna (user). Berikut disajikan penjelasan mengenai bagaimana proses pengurutan data dalam Use-case Diagram.

Gambar 3.3 Use-case Diagram

3.4.2 Activity Diagram

Actifity Diagram menggambarkan berbagai aktifitas alir data didalam sistem yang

(20)

Gambar 3.4 Diagram Actifity Sistem

3.4.3 Sequence Diagram

(21)

Gambar 3.5 Sequence Diagram Sistem

3.5 Flowchart Sistem

(22)

3.5.1 Flowchart Algoritma Bucket Sort

Flowchart Algoritma Bucket Sort dapat kita lihat pada gambar 3.6 seperti dibawah ini.

ya

tidak

ya

tidak

Gambar 3.6 Flowchart Algoritma Bucket Sort

mulai

Temp=array

Index=cell((arr[i]*a rr.length)/max)

Temp[index].le ngth=0

j=0

Temp[index][j] <arr[i]

J++

i++

i<arr.length swap

Arrange result

selesai Temp[index][

(23)

3.5.2 Flowchart Algoritma Strand Sort

Flowchart Algoritma Strand Sort dapat kita lihat pada gambar 3.7 seperti dibawah ini.

tidak

ya tidak

ya

tidak

Gambar 3.7 Flowchart Algoritma Strand Sort Mulai

j=i-1

index=i;

Arr[i]<arr[j]

j<0 Index=j;

j++

Swap; i++ i++

i<(arr.length-1)

(24)

3.5.3 Flowchart Algoritma Quick Sort 2 Pivot

Flowchart Algoritma Quick Sort 2 Pivot dapat kita lihat pada gambar 3.8

tidak ya

tidak

ya

Gambar 3.8 Flowchart Algoritma Strand Sort

Mulai

n data bilangan

Tentukan Pivot (x1,x2)

Ap1>=x1||Aq1<=x1

Ap2>=x2||Aq2<=x2 Swap Ap1,Aq1

Swap Ap2,Aq2

Data belum terurut

Bagi partisi

Proses Sorting

Selesai

(25)

3.6 Alur Proses Sistem

3.6.1 Alur Proses Algoritma Bucket Sort

Alur proses untuk Encode dengan Algoritma Quick Sort dapat digambarkan dengan pseudocode berikut.

Tempt = array[arr.length][arr.length]; For (i=0, i<arr.length, i++){

Index = celling((arr[i]*arr.length)/max) If (temp[index].length=0)

Temp[index][0]=arr[i]; }

Else { j=0;

while (temp[index][j]<arr[i]) j++;

} {

Swap(j, arr[i],temp[index]); }

(26)

3.6.1.1 Proses Algoritma Bucket Sort.

Pada gambar dibawah, data pada list akan diproses satu per satu hingga semua data pada list diproses hingga selesai. Selanjutnya proses pengurutan data akan terjadi didalam Bucket (ember), dan selanjutnya data yang didalam Bucket akan menghasilkan data secara terurut.

12 22 24 1 5 21 23 5 2 3

0 1 2 3 4 5 6 7 8 9

Gambar 3.9 Gambar Algoritma Bucket Sort

Cara kerja algoritma bucket sort dapat dijelaskan sebagai berikut :  Tentukan array yang ingin diurutkan.

 Tentukan jumlah bucket dan rentang masing-masing bucket.  Masukkan array tersebut ke dalam bucket yang telah ditentukan.  Di dalam masing-masing bucket, array tersebut di urutkan.

 Setelah itu keluarkan hasil urutan dari dalam bucket dan kembalikan ke array awal.

1 2 3 5 5 12 21 22 23 24

Proses penghitungan Bucket

=((value*number of elemen)/max arr value+1)

(27)

Kelebihan dari Bucket Sort:

5. Sebuah algortima yang stabil 6. Prosesnya cepat.

7. Hanya berlaku pada kisaran 0 sampai nilai maksimum (M).

8. Lebih terkhusus, dapat digunakan ketika kuncinya dapat digunakan sebagai penghitungan.

3.6.2 Alur Proses Algoritma Strand Sort

Alur proses untuk Encode dengan Algoritma Quick Sort dapat digambarkan dengan

pseudocode berikut.

For (i=1 to (array.length-1)) j=i-1; index;

while (arr[i]<arr[j]{ index=j;

j--; if (j<0) break; }

Swap(i,index)

3.6.2.1 Contoh Proses Algoritma Strand Sort

40 2 1 43 3 65 0 -1 58 3 42 4

2 40 1 43 3 65 0 -1 58 3 42 4

1 2 40 43 3 65 0 -1 58 3 42 4

(28)

1 2 3 40 43 65 0 -1 58 3 42 4

0 1 2 3 40 43 65 -1 58 3 42 4

-1 0 1 2 3 40 43 65 58 3 42 4

-1 0 1 2 3 40 43 58 65 3 42 4

-1 0 1 2 3 3 40 43 58 65 42 4

-1 0 1 2 3 3 40 42 43 58 65 4

-1 0 1 2 3 3 4 40 42 43 58 65

Gambar 3.10 Gambar Algoritma Strand Sort

(29)

3.6.3 Alur Proses Algoritma Quick Sort 2 Pivot

Alur proses untuk Encode dengan Algoritma Quick Sort dapat digambarkan dengan

pseudocode berikut.

Algoritma Quick Sort 2 Pivot (A,lo,hi) is If lo < hi then

P:= partition (A,lo,hi) Quicksort (A,lo,P-1) Quicksort (A,P+1,hi) Algoritma partition (A,lo,hi) is Pivot:= A[hi]

i:= lo //place for swapping for j:= lo to hi-1 do

if A[j] <= pivot then swap A[i] with A[j] i:= i+1

swap A[i] with A[hi] return i

3.6.3.1 Proses Algoritma Quick Sort 2 Pivot

Data yang akan diurutkan dengan algoritma quick sort 2 pivot

2 19 1 2 20 3 11 90 3

Pilih 2 Pivot secara acak (yang berwarna merah), nilai yang lebih kecil dari pivot akan ditempatkan disebelah kiri dari pivot dan yang lebih besar ditempatkan di sebelah kanan pivot.

2 19 1 2 20 3 11 90 3

2 1 2 3 3 19 11 20 90

Selanjutnya pilih lagi dua pivot dari list selain pivot yang telah dipilih, dan selanjutnya.

2 1 2 3 3 19 11 20 90 Hasil akhir dari Pengurutan data:

(30)

Langkah-langkah algoritma Quick Sort 2 Pivot :

 Pilih nilai pivot. Kita ambil nilai di awal, ditengah, maupun diakhir secara acak (random) elemen sebagai sebagai nilai dari pivot, dalam algoritma ini menggunakan 2 elemen yang menjadi pivotnya.

 Partisi Atur ulang semua elemen sedemikian rupa, lalu semua elemen yang lebih rendah daripada pivot dipindahkan ke sebelah kiri dari array/list dan semua elemen yang lebih besar dari pivot dipindahkan ke sebelah kanan dari array/list. Nilai yang sama dengan pivot dapat diletakkan di mana saja dari array. Ingat,mungkin array/list akan dibagi dalam bagian yang tidak sama.  Urutkan semua bagian (kiri/kanan) elemen dari data tersebut.

 Selanjutnya akan menghasilkan data yang sudah terurut Kelebihan:

Algoritma Quicksort memiliki kompleksitas O(n log n) dimana pada prakteknya lebih cepat dari algoritma pengurutan lainnya.

Kekurangan:

(31)

BAB 4

IMPLEMENTASI SISTEM

4.1. Pendahuluan

Masalah ataupun problema yang diangkat dalam penelitian ini adalah bagaimana menganalisis kompleksitas waktu (Big O) dengan menggunakan algoritma Bucket Sort, Strand Sort dan Quick Sort 2 Pivot.

Diagram Ishikawa (fishbone diagram) biasanya disebut juga diagram

sebab akibat yang biasanya digunakan untuk mengidentifikasi masalah yang ada pada sistem yang akan dirancang. Dengan

diagram ini kita dapat mengidentifikasi, mengeksplorasi dan menggambarkan suatu masalah dengan mengikutsertakan sebab dan akibat dari permasalahan dalam visual grafis. Dengan demikian proses pencapaian sistem akan sangat dibantu dengan adanya Diagram Ishikawa seperti pada gambar 4.1.

pengurutan data lebih cepat memudahkan pekerjaan manusia kesalahan dalam pengurutan minim

Prosesor Core i3 2 GHz Metode Bucket sort, Strand Sort RAM, 2 GB Dan Quick sort 2 pivot

[image:31.595.91.566.423.612.2]

Aplikasi Pemrograman C# OS Win 7 ultimate

Gambar 4.1 Diagram Ishikawa untuk Implementasi Penelitian

4.2 Generate Data

Generate data merupakan proses untuk membangkitkan data acak. Dalam hal ini, kita ambil contoh dengan Max Item (n)=10 dan Max Item Value= 1000. Dalam proses Compile, akan terlihat berapa lama waktu (running time) dan grafik dari proses Algoritma Sorting. Hasilnya dapat kita lihat pada gambar 4.2

Material Manusia

Mesin Metode

(32)

[image:32.595.111.510.84.318.2]

Gambar 4.2 Tampilan Utama Sorting Data

4.3 Hasil Uji Coba

Pada penelitian ini dilakukan pengamatan pada 3 metode pengurutan yaitu Bucket Sort, Strand Sort, dan Quick Sort 2 Pivot. Diberikan nilai input Max Item Value 1000 dan 1000000, sedangkan nilai Max Item pada 10, 500 dan 1000 untuk masing-masing Max Item Value tersebut. Dan data yang diberikan untuk ketiga kondisi tersebut juga sama. Berikut akan ditampilkan hasil pengamatan yang sudahdilakukan.

4.3.1 Pengurutan pada Max Item = 10

(33)

[image:33.595.110.530.89.349.2]

Gambar 4.3 Item Tampilan hasil pada max item 10 dan Max Value 1000

a. Max Item Value = 1000

Pada kondisi max item 10 dan Max Item Value 1000 terlihat hasil pengurutan data seperti gambar 4.4 Dari ketiga metode yang digunakan dapat diamati bahwa pada kondisi ini waktu eksekusi yang paling cepat yaitu pada metode strand sort sebesar 354,8 x 10-3 sec, bucket sort sebesar 650,9x 10-3 sec, selanjutnya quick sort 2 pivot sebesar 1163,6 x 10-3 sec. Dari ketiga nilai eksekusi tersebut metode quick sort 2 pivot memiliki waktu eksekusi yang paling lama untuk kondisi max item 10. Dari hasil ini terlihat bahwa metode strand sort cukup baik dalam melakukan sorting dibandingkan bucket sort dan quick sort 2 pivot untuk kondisi ini.

[image:33.595.111.511.579.734.2]

(34)

[image:34.595.110.534.150.220.2]

Pada gambar 4.5 jelas telihat perbedaan kompleksitas waktu dari ketiga metode sorting yang ditampilakan pada grafik, yang menujukan waktu terbaik adalah strand sort dan terburuk ada pada algoritma quick sort 2 pivot.

Gambar 4.5 Grafik perbandingan ketiga pengurutan untuk Max Item 10 Max Item Value = 1000

b. Max Item Value = 1000000

Pengurutan pada Max Item 10 dilakukan denganMax Item Value yaitu Max Item Value = 1000000.

[image:34.595.107.532.309.541.2]

(35)

[image:35.595.108.520.83.265.2]

a. Bucket sort b. Strand sort c. Quick sort 2 pivot Gambar 4.7 Hasil pengurutan pada Max item 10 dan

Max Item Value 1000000

[image:35.595.112.534.440.532.2]

Grafik pada gambar 4.8 menunjukan perbedaan kompleksitas waktu untuk ketiga metode pengurutan tidak begitu signifikan antara strand sort dan quick sort 2 pivot, sedangkan dengan bucket sort sangat jauh signifikan. dan strand sort pada percobaan ini lebih unggul dari kedua pengurutan lainnya.

4.3.2 Pengurutanpada Max Item = 500

(36)

[image:36.595.110.545.102.357.2]

Gambar 4.9 Pengurutan Pada Max Item 500 Max Item Value=1000

a. Max Item Value = 1000

Pada kondisi Max item 500 dan Max Item Value 1000 dengan data yang diberikan pada ketiga kondisi sama maka diperoleh hasil pengurutan seperti pada gambar 4.9. Pada kondisi ini waktu eksekusi tercepat pada metode bucket sort sebesar 99,2 x 10-3 sec, selanjutnya quick sort 2 pivot sebesar 240,4 x 10-3 sec dan strand sort sebesar 661,7 x 10-3 sec. Pada kondisi ini metode strand sort memerlukan waktu paling lama untuk eksekusi bila dibandingkan dengan kedua metode lainnya.

a. Bucket sort b. Strand sord c. Quick sort 2 pivot Gambar 4.10 Hasil pengurutan pada Max item 500 dan

[image:36.595.110.505.548.721.2]

(37)

[image:37.595.109.490.189.284.2]

Percobaan ini memperlihatkan bahwa Bucket sort jauh lebih unggul kompleksitas waktunya daripada strand sort dan quick sort 2 pivot untuk max item 500 dan max item value 1000, terlihat pada grafik pada gambar 4.11 Namun bucket sort dan strand sort memiliki perbedaan yang signifikan dan untuk percobaan ini bucket sort lebih unggul dari kedua lainnya.

Pengurutan pada Max Item 500 dilakukan dengan Max Item Value yaitu Max Item Value = 1000000.

[image:37.595.109.526.418.694.2]

(38)

Pada kondisi Max item 500 dan Max Item Value 1000000 dengan data yang diberikan pada ketiga kondisi sama maka diperoleh hasil pengurutan seperti pada gambar 4.13 Pada kondisi ini waktu eksekusi tercepat adalah metode quick sort 2 pivot sebesar 230,1 x 10-3 sec, selanjutnya strand sort sebesar 614,8 x 10-3 sec dan yang paling lambat adalah metode bucket sort sebesar 417591,5 x 10-3 sec. Pada kondisi ini metode bucket sort memerlukan waktu paling lama untuk eksekusi bila dibandingkan dengan kedua metode lainnya dan dengan perbedaan yang sangat signifikan.

[image:38.595.111.520.272.454.2]

[image:38.595.108.510.619.719.2]

Metode pengurutan yang paling unggul adalah metode quick sort 2 pivot, memiliki waktu yang lebih baik dari strand sort dan bucket sort walaupun quick sort 2 pivot dengan strand sort memiliki durasi waktu yang hampir sama, tapi quick sort 2 pivot dan strand sort memiliki perbedaan yang sangat signifikan dengan bucket sort. Berikut grafik perbandingannya.

(39)

4.3.3 Pengurutanpada Max Item = 1000

[image:39.595.144.516.156.418.2]

Pengurutan pada Max Item 1000 dilakukan dengan membandingkan pada 2 nilai Max Item Value yaitu Max Item Value = 1000 dan 1000000.

Gambar 4.15 Pengurutan Pada Max Item 1000 Max Item Value=1000 a. Max Item Value = 1000

(40)

[image:40.595.108.498.83.291.2]

Max Item Value 1000

Kecepatan kompleksitas waktu Bucket sort selalu lebih baik dibandingkan dengan kedua pengurutan lainnya jika max item dan max item valuenya bernilai besar atau sama. Perbedaan kompleksitas waktu telihat pada grafik dibawah ini.

[image:40.595.109.476.424.539.2]

(41)

[image:41.595.109.537.130.427.2]

Pengurutan pada Max Item 1000 dilakukan dengan Max Item Value yaitu Max Item Value = 1000000.

(42)

[image:42.595.110.474.83.285.2]

a. Bucket sort b. Strand sort c. Quick sort 2 Pivot Gambar 4.19 Hasil pengurutan pada Max item 1000 dan

Metode Quick sort 2 pivot dan metode strand sort selalu lebih baik dari metode Bucket sort. Pada grafik jelas telihat keunggulan 2 pengurutan yang penulis tambahakan dengan max item 1000 dan max value 1000000, dan untuk mengurutkan data yang sangat banyak disarankan untuk menggunakan metode Quick sort 2 pivot dan Strand sort, karena jika mengurutkan data dengan jumlah yang sangat banyak akan sangat lama jika menggunakan metode Bucket sort. Perbedaan kompleksitas terlihat pada grafik dibawah ini.

4.4 Pembahasan

[image:42.595.104.498.481.540.2]

(43)

Pada pengujian Max Item 500 dengan Max Item Value 1000 dan 1000000, perbedaan waktu eksekusi sangat terlihat antara ketiga algoritma yang diujikan. Perbedaan waktu eksekusi yang dihasilkan dalam pengujian yang dilakukan antara bucket sort dan quick sort 2 pivot memiliki perbedaan yang tidak begitu signifikant dan memiliki perbedaan waktu yang sedikit, sedangkan dengan menggunakan metode strand sort sangat berbeda, jauh lebih lama dari kedua algoritma lainnya. Tapi dengan Max Item Value 1000 malah sebaliknya, bucket sort sangat lama dan sangat lambat dibandingkan strand sort dan quick sort 2 pivot. Quick sort 2 pivot menjadi metode yang paling cepat. Dalam pengujian ini kita dapat megetahui bahwa ada kelebihan dan kekurangan dari ketiga algoritma tersebut, itu tergantung kepada besar kecilnya data yang ingin diurutkan dan apa yang dibutuhkan oleh pengguna (user).

Dari hasil pengujian bahwa Quick sort 2 pivot lebih baik dari kedua metode ini, selanjutnya strand sort dan terakhir bucket sort untuk mengurutkan data yang banyak. Sedangkan jika kita ingin mengurutkan data yang jumlahnya sedikit, kita lebih baik menggunakan metode strand sort. Dan jika kita ingin mengurutkan data yang max item nya hampir sama dengan max item value, lebih baik kita menggunakan metode Bucket sort.

4.5 Hasil Perhitungan Kompleksitas Big Theta (�)

Untuk mengetahui algoritma mana yang lebih efektif pada pengurutan data maka dibutuhkan perhitungan kompleksitas waktu. Dapat dilihat pada tabel 4.1 untuk algoritma Bucket Sort, tabel 4.2 untuk algoritma Strand Sort dan gambar 4.30 untuk algoritma Quick sort 2 pivot.

[image:43.595.107.535.642.772.2]

4.5.1 Hasil penghitungan Big Tetha Bucket Sort

Tabel 4.1 Perhitungan Big Theta pada Bucket Sort

Step Pseudocode T(n)

1 public static Bucket sort; C # C*#

2 Tempt = array [arr.length][arr.length]; C1 1 C1 3 For (i=0, 0<arr.length, i++){ C2 n C2n 4 Index = celling ((arr[i]*arr.length)/max) C3 n2 C3n2

(44)

Dari perhitungan running time pada tabel maka didapat:

T(n) = C1 + C2n+ C3n2 + C3n2 + C4n2 + C1n2 + C1n2 + C5n + C6n +C7n+C8n = C1 + C2n + 2 C1n2 + C3n2 + C4n2 +C5n+ C6n+C7n+C8n

= C1 + (C2+ C4+ C5+ C6+ C7+ C8 )n+ (2 C1 + C3+ C4 ) n2 T(n) = θ(n)

[image:44.595.108.537.109.343.2]

4.5.2 Hasil penghitungan Big Tetha Strand Sort

Tabel 4.2 Perhitungan Big Theta pada Strand Sort

6 Tempt [index][0]=arr[j] C1 n2 C1n2

7 }

Else{

C1 n2 C1n2

9 J=0; C5 n C5 n

10 While (tempt[index][j]<arr[i]; J++

C6 n C6n

11 } {

Swap (j, arr[i], tempt[index]);

C7 n C7n

13 }

Return tempt[];

C8 n C8n

Step Pseudocode T(n)

1 public static Strand sort; C # C*#

2 For (i=1 to (array.length-1)) C1 1 C1

3 J=i-1; index; C2 N C2n

4 While (arr[i]< arr[j]{ C3 n2 C3n2

(45)

Dari perhitungan running time pada tabel maka didapat: T(n) = C1 + C2n+ C3n2 + C4n2 + C5n2 + C6n2 + C7n + C8n = C1 + (C2+ C7+ C8 )n+ (C3 + C4+ C5+ C6 ) n2

T(n) = θ(n2)

4.5.3 Hasil penghitungan Big Tetha Algoritma Quick sort 2 Pivot

Data yang akan diurutkan dengan algoritma quick sort 2 pivot

2 19 1 2 20 3 11 90 3

Pilih 2 Pivot secara acak (yang berwarna merah), nilai yang lebih kecil dari pivot akan ditempatkan disebelah kiri dari pivot dan yang lebih besar ditempatkan di sebelah kanan pivot.

2 19 1 2 20 3 11 90 3

2 1 2 3 3 19 11 20 90

Selanjutnya pilih lagi dua pivot dari list selain pivot yang telah dipilih, dan selanjutnya.

2 1 2 3 3 19 11 20 90 Hasil akhir dari Pengurutan data:

2 2 2 3 3 11 19 20 90

n 9 4 1

hdc 3 2 1

h_dc’ 2 1 0

6 j--; C5 n2 C5n2

7 If (j<0) C6 n2 C6n2

9 Break; }

C7 n C7 n

(46)

hdc’=hdc-1

3hdc’+1=n

hdc’ log 3+log 1= log n h_dc’=3log n

h_dc’=hdc-1

3

log n= hdc-1 h_dc’=3log n+1

H = hdc+hc-1

=3log n+1+1-1 =3log n+1 T(n) = w.H

= n. 3log n+1 = 1

log 3n log n+n

= ϴ(n log n)

[image:46.595.104.532.631.719.2]

Jika dibandingkan dari kompleksitas waktu kedua algoritma tersebut maka algoritma yang running time-nya lebih cepat adalah algoritma Quick sort 2 Pivot. Quick sort 2 pivot memiliki running time yang lebih cepat dibandingkan Bucket sort maupun Strand sort, karena nilai n log n lebih kecil dari n2 dan n. Hal ini juga dapat dipengaruhi oleh kemampuan komputer, jumlah memori dan faktor lain. Namun jika jumlah data atau elemen array yang sangat banyak, perbedaan running time Quick sort 2 Pivot, Strand sort dan Bucket sort akan sangat terlihat, semakin banyak data yang akan diurutkan, semakin terlihat perbedaan running time-nya.

Tabel 4.3 Perbandingan ketiga Algoritma

Algoritma Kompleksitas (Big O)

Bucket Sort n

Strand Sort n2

(47)

BAB 5

PENUTUP

Bab ini berisi kesimpulan dari seluruh bab sebelumnya, serta saran yang diharapkan dapat bermanfaat dan membangun dalam proses pengembangan untuk penelitian berikutnya.

5.1Kesimpulan

1. Kompleksitas waktu (Running time) diperlukan sebagai acuan untuk menentukan perhitungan secara teori untuk mendapatkan satuan waktu untuk proses pengurutan data.

2. Pengurutan data berdasarkan pengurutan Ascending (Menaik). Dan data acak yang disajikan penulis yaitu dengan Integer.

3. Hasil analisis perbandingan ketiga metode pengurutan menunjukkan bahwa running time Quick sort 2 Pivot dan Strand sort lebih cepat daripada Bucket sort. hal ini akan terlihat jika jumlah data yang akan diurutkan berjumlah banyak/besar, semakin banyak/besar data semakin terlihat perbedaan kecepatan algoritma, namun waktu pengurutan tergantung pada algoritma, jumlah data, dan platform yang digunakan sesuai dengan kebutuhan.

4. Setiap algoritma memiliki kekurangan dan kelebihan masing-masing, hal ini terlihat saat jumlah data yang akan diurutkan berjumlah sedikit/kecil, akan lebih baik menggunakan algoritma Bucket sort, sedangkan untuk jumlah data yang banyak/besar lebih baik menggunakan algoritma Quick sort 2 pivot ataupun Strand sort

5.2Saran

(48)

BAB 2

LANDASAN TEORI

2.1 Pengertian Algoritma

Algoritma adalah urutan langkah-langkah logis penyelesaian masalah yang disusun secara sistematis dan logis. Kata Logis merupakan kata kunci dalam Algoritma. Langkah-langkah dalam Algoritma harus logis dan harus dapat ditentukan bernilai salah atau benar (Rosa dan Shalahuddin 2010). Kriteria Algoritma yang baik :

a. Tepat, benar, sederhana, standar dan efektif. b. Logis, terstruktur dan sistematis.

c. Semua operasi terdefinisi.

d. Semua proses harus berakhir setelah sejumlah langkah dilakukan.

e. Ditulis dengan bahasa yang standar dengan format pemrograman agar mudah untuk diimplementasikan dan tidak menimbulkan arti ganda.

(49)

2.2 Algoritma Pengurutan ( Sorting )

Algoritma merupakan urutan aksi-aksi yang dinyatakan dengan jelas dan tidak rancu untuk memecahkan suatu masalah dalam rentang waktu tertentu. Sedangkan pengurutan adalah proses pengaturan sekumpulan objek berdasarkan urutan atau susunan tertentu, dapat berupa pengurutan menaik (ascending) atau menurun (descending).

Contoh, sebuah larik atau array terdiri dari kumpulan bilangan : [3,12,1,50,33,5,28]  Hasil pengurutan menaik (ascending) : [1,3,5,12,28,33,50]

 Hasil pengurutan menurun (descending) : [50,33,28,12,5,3,1]

Sebuah algoritma dikatakan baik jika menghasilkan nilai yang benar, efektif dan efisien. Efektif yaitu tepat sasaran, jelas dan tidak rancu dalam menjalankan aksi-aksinya serta menghasilkan data yang benar. Efisien yaitu penghematan proses dari sebuah algoritma, seperti running time dan penggunaan memori. Metode atau algoritma pengurutan dapat diklasifikasikan menjadi :

1. Metode atau algoritma pengurutan internal, yaitu pengurutan yang dilakukan di dalam larik itu sendiri. Datanya disimpan di dalam memori komputer. 2. Metode atau algoritma pengurutan eksternal, yaitu pengurutan yang datanya

disimpan di dalam disk storage. Metode ini disebut juga pengurutan arsip. Sedangkan berdasarkan kestabilan (stability), algoritma pengurutan dapat dibagi menjadi dua jenis, yaitu :

1. Metode pengurutan stabil (stable sorting algorithm), merupakan algoritma pengurutan yang menjaga/mempertahankan (maintenance) urutan dari beberapa elemen array yang bernilai sama.

(50)

melakukan perulangan dengan melakukan pemanggilan terhadap dirinya sendiri. Contoh algoritma pengurutan yang termasuk dalam skema iteratif, yaitu pengurutan apung (bubble sort) dan selection sort, Contoh algoritma pengurutan yang termasuk dalam skema rekursif, yaitu pengurutan merge (merge sort), pengurutan heap (heap sort) dan pengurutan cepat (quick sort). Tidak semua algoritma tersebut hanya memiliki satu skema, misalnya algoritma pengurutan seleksi atau selection sort yang dapat menggunakan skema rekursif, namun di dalam penelitian ini selection sort yang dibahas menggunakan skema iteratif (Fanani 2008).

2.3 Kompleksitas Algoritma

Efisiensi sebuah algoritma tergantung dari beberapa hal, diantaranya adalah :  Kinerja CPU

 Kinerja Memori  Kinerja Disk  Kinerja Jaringan

Menurut Rao dan Ramses (2012), bahwa Algoritma memiliki kompleksitas yang merupakan acuan utama utama untuk mengetahui kecepatan dari sebuah algoritma. Kompleksitas dibagi menjadi tiga, yaitu:

1. Best case (Ω), yaitu kompleksitas algoritma dimana algoritma tersebut berjalan dalam kondisi terbaik.

2. Average case (�), yaitu kompleksitas algoritma dimana algoritma tersebut berjalan dalam kondisi sedang, biasanya inputnya secara acak.

3. Worst case (Ο), yaitu kompleksitas algoritma dimana algoritma tersebut berjalan dalam kondisi terburuk.

2.4 Growth Fuction

(51)

[image:51.595.102.534.104.680.2]

Tabel 1.1 Tabel Notasi Big O

Notasi Nama Contoh Aplikasi

O(1) Konstan Menentukan apakah suatu bilangan ganjil atau genap

O(log * n) Iterasi Logaritmik Algoritma pencarian Hopcraff dan Ullman untuk himpunan disjoint

O(log n) Logaritmik Pencarian dalam list terurut dengan Binary Search Algorithm

O((log n)c) Polilogaritmik Menentukan bilangan prima dengan AKS primality test

O(n) Linear Pencarian dalam list tidak terurut O(n log n) Linearitmik Mengurutkan list dengan Heapsort O(n2) Kuadratik Mengurutkan list dengan Insertion Sort

O(nc),c>1 Poliomial Pencarian shortest path dengan algoritma Floyd Warshall

O(cn) Eksponensia Pencarian solusi untuk traveling salesmen problem

O(n!) Faktorial Menyelesaikan traveling salesmen problem dengan menggunakan brute force

(52)

2.5 Notasi Asimptotik

Notasi asimptotik digunakan untuk menentukan kompleksitas suatu algoritma dengan melihat waktu tempuh (running time) sebuah algoritma. Waktu tempuh algoritma

merupakan fungsi : N → R suatu algoritma dengan algoritma lainnya. Notasi

asimptotik dapat dituliskan dengan beberapa simbol, yaitu :

 Notasi Big O, yaitu notasi asimptotik sebuah fungsi algoritma untuk batas atas.  Notasi Little o, yaitu notasi asimptotik sebuah fungsi algoritma untuk batas

atas namun tidak secara ketat terikat (not asymptotically tight).

 Notasi Theta (�), yaitu notasi asimptotik sebuah fungsi algoritma untuk batas atas dan bawah.

 Notasi Omega ( ), yaitu notasi asimptotik sebuah fungsi algoritma untuk batas bawah, notasi ini berlawanan dengan notasi little-o.

2.6 Algoritma Bucket Sort

(53)

Proses pengurutan yang dilakukan dengan menggunakan algoritma bucket sort adalah dengan cara membagi dan memecahkan himpunan array ke dalam beberapa ember (bucket) virtual secara merata. Setelah selesai maka dikumpulkan kembali ke array aslinya, sehingga mendapatkan susunan array yang sudah terurut.

Cara kerja algoritma bucket sort dapat dijelaskansebagai berikut :  Tentukan array yang ingin diurutkan.

 Tentukan jumlah bucket dan rentang masing-masing bucket.  Masukkan array tersebut ke dalam bucket yang telah ditentukan.  Di dalam masing-masing bucket, array tersebut di urutkan.

 Setelah itu keluarkan hasil urutan dari dalam bucket dan kembalikan ke array awal.

Kelebihan dari Bucket Sort:

1. Sebuah algortima yang stabil 2. Prosesnya cepat.

3. Hanya berlaku pada kisaran 0 sampai nilai maksimum (M).

4. Lebih terkhusus, dapat digunakan ketika kuncinya dapat digunakan sebagai penghitungan.

2.6.1 Pseudocode Algoritma Bucket Sort

Tempt = array[arr.length][arr.length]; For (i=0, i<arr.length, i++){

Index = celling((arr[i]*arr.length)/max) If (temp[index].length=0)

Temp[index][0]=arr[i]; }

Else { j=0;

while (temp[index][j]<arr[i]) j++;

(54)

{

Swap(j, arr[i],temp[index]); }

Return temp[];

2.7 Algoritma Strand Sort

Strand Sort adalah sebuah algoritma pengurutan yang membandingkan dua elemen data. Pertama, mengurutkannya, kemudian mengecek elemen data berikutnya satu persatu dan membandingkannya dengan elemen data yang telah diurutkan. Ide dasar

dari algortima Strand Sort ini adalah mencari tempat yang “tepat” untuk setiap elemen

array, dengan cara sequential search. Proses ini kemudian menyisipkan sebuah elemen array yang diproses ke tempatnya yang seharusnya. Proses ini dilakukan sebanyak N-1 tahapan dengan indeks yang dimulai dari 0. Proses pengurutan dengan menggunakan algoritma Strand Sort dilakukan dengan cara membandingkan data ke-i (dimana i dimulai dari data ke-2 sampai dengan data terakhir) dengan data berikutnya. Jika ditemukan data yang lebih kecil maka data tersebut disisipkan kedepan sesuai dengan posisi yang seharusnya.

Proses algoritma Strand Sort bertujuan untuk menjadikan bagian sisi kiri array terurutkan sampai dengan seluruh array berhasil diurutkan. Metode ini mengurutkan bilangan-bilangan yang telah dibaca dan berikutnya secara berulang akan menyisipkan bilangan-bilangan dalam array yang belum terbaca kesisi kiri array yang telah terurut. Strand Sort bekerja seperti banyak orang yang sedang mengurutkan kartu ditangan. Dimulai dengan tangan kiri yang kosong dan kartunya ditumpuk di meja. Selanjutnya kita ambil satu persatu kartu di meja dan diletakkan ditangan kiri dengan posisi yang benar (terurut). Untuk menemukan posisi yang benar, maka kita harus membandingkan satu persatu kartu yang ada (ditangan kiri) secara berurutan.

Kelebihan dan kekurangan Strand Sort : Kelebihan:

(55)

3. Jika list sudah terurut atau sebagian terurut maka algoritma Strand Sort akan lebih cepat daripada Quick Sort.

4. Prosesnya cepat dalam data yang sebagian sudah terurut. 5. Lebih cepat dibandingkan Bubble Sort dan Selection Sort.

6. Loop (Perulangan) pada Strand Sort sangat cepat, sehingga termasuk menjadi salah satu algoritma pengurutan tercepat dalam jumlah elemen yang sedikit. 7. Stabil

Kekurangan :

1. Banyaknya operasi yang diperlukan dalam mencari posisi yang tepat untuk elemen List.

2. Untuk List yang jumlahnya besar algoritma Strand Sort tidak praktis.

3. Jika List terurut terbalik sehingga setiap eksekusi dari perintah harus memindai dan mengganti seluruh bagian sebelum menyisipkan elemen berikutnya. - Membutuhkan metode tambahan.

2.7.1 Pseudocode Algoritma Strand Sort

For (i=1 to (array.length-1)) j=i-1; index;

(56)

j--; if (j<0) break; }

Swap(i,index)

2.8. Algoritma Quick Sort 2 Pivot

Quicksort merupakan Algoritma Sorting yang dikembangkan oleh Tony Hoare yang, secara kasus rata-rata, membuat pengurutan O(n log n) untuk mengurutkan n item. Algoritma ini juga dikenal sebagai Partition-Exchange Sort atau disebut sebagai Sorting Pergantian Pembagi. Pada kasus terburuknya, algoritma ini membuat perbandingan O(n2), malaupun kejadian seperti ini sangat langka. Quicksort sering lebih cepat dalam praktiknya daripada algoritma O(n log n) yang lainnya. Dan juga, urutan dan referensi lokalisasi memori quicksort bekerja lebih baik dengan menggunakan cache CPU, jadi keseluruhan sorting dapat dilakukan hanya dengan ruang tambahan O(log n).

Quicksort merupakan sorting pembanding dan pada implementasi efisien tidak merupakan algoritma sorting yang stabil. Algoritma seleksi memilih jumlah list k yang terkecil, masalah ini merupakan yang paling mudah secara umumnya daripada sorting. Algoritma seleksi yang sederhana teatpi efektif bekerja hampir sama seperti quicksort, kecuali yang daripada memanggil rekursif pada kedua sublist, algoritma ini hanya membuat satu pemanggilan rekursif ekor pada sublist yang mengandung elemen yang diinginkan. Perubahan kecil ini menurunkan kerumitan rata-rata pada linear atau O(n) kali, dan membuatnya menjadi Algoritma In-Place. Ragam algoritma ini membawa worst case turun menjadi O(n).

(57)

menjadi pilihan sebagai elemen pivot. Dalam algoritma ini digunakan 2 Pivot, dan pivotnya bisa dipilih secara acak ataupun berurutan. Sayangnya, ini menyebabkan perilaku worst-case pada array yang telah diurut, yang merupakan penggunaan kasus yang sering dipakai. Masalah ini dengan mudah diselesaikan dengan memilih salah satu dari index acak untuk pivot, memilih indek tengah dari partisi atau (secara khusus untuk partisi panjang) memilih median dari elemen awal, tengah, dan akhir dari partisi untuk pivot

Memilih elemen pivot juga rumit dengan dengan kehadiran dari Integer Overflow. Jika indeks batas dari subarray yang diurutkan cukup besar, ungkapan naif untuk indeks tengah, (kiri + kanan)/2, akan menyebabkan luapan dan memberikan indeks pivot yang salah. Masalah ini dapat terselesaikan dengan menggunakan, sebagai contoh, kiri + (kanan-kiri)/2 pada indeks elemen tengah, pada masalah dari aritmatika kompleks. Masalah yang sama muncul pada beberapa metode yang lain dari pemilihan elemen pivot

Algoritma quick sort mengurutkan dengan sangat cepat, namun algoritma ini sangat komplex dan diproses secara rekursif. Sangat memungkinkan untuk menulis algoritma yang lebih cepat untuk beberapa kasus khusus, namun untuk kasus umum, sampai saat ini tidak ada yang lebih cepat dibandingkan algoritma quick sort.

Quick Sort merupakan suatu algoritma pengurutan data yang menggunakan teknik pemecahan data menjadi partisi-partisi, sehingga metode ini disebut juga dengan nama partition exchange sort. Untuk memulai irterasi pengurutan, pertama-tama sebuah elemen dipilih dari data, kemudian elemen-elemen data akan diurutkan diatur sedemikian rupa.

Langkah-langkah algoritma Quick Sort 2 Pivot :

 Pilih nilai pivot. Kita ambil nilai di awal, ditengah, maupun diakhir secara acak (random) elemen sebagai sebagai nilai dari pivot, dalam algoritma ini menggunakan 2 elemen yang menjadi pivotnya.

(58)

 Urutkan semua bagian (kiri/kanan) elemen dari data tersebut.  Selanjutnya akan menghasilkan data yang sudah terurut Kelebihan:

Algoritma Quicksort memiliki kompleksitas O(n log n) dimana pada prakteknya lebih cepat dari algoritma pengurutan lainnya.

Kekurangan:

Pada kemungkinan terburuknya, algoritma Quicksort ini dapat memiliki kompleksitas O(n2). Meskipun ini sangat langka terjadi