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

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

}

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

}

arr[index] = temp; } return arr; } } } using System; using System.Collections.Generic; using System.Linq; using System.Text;

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

exchange(input, i, gt--); } else { i++; } }

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

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

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

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

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

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

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

}

void Button2Click(object sender, EventArgs e) {

txtBucketSort.Text = ""; txtStrandSort.Text = ""; txtQuickSort.Text = "";

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

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

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

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

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

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

rtmBucket =

Math.Round(Convert.ToDecimal(watch3.Elapsed.TotalMilliseconds * 1000), 4); textBox11.Text = rtmBucket.ToString();

}));

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)

progressBar.BeginInvoke(new Action(() => progressBar.Value = progress));

else

progressBar.Value = progress; }

public void SetLabelMessage(string text) {

if (progressBar.InvokeRequired)

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

else

lblText.Text = text; }

public void SetTitle(string text) {

if (progressBar.InvokeRequired)

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

{

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

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

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

this.label2.Location = new System.Drawing.Point(22, 75); this.label2.Name = "label2";

this.label2.Size = new System.Drawing.Size(92, 15); this.label2.TabIndex = 1;

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.AutoSize = true;

this.label3.Location = new System.Drawing.Point(18, 104); this.label3.Name = "label3";

this.label3.Size = new System.Drawing.Size(63, 13); this.label3.TabIndex = 10;

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

// label4 //

this.label4.AutoSize = true;

this.label4.Location = new System.Drawing.Point(241, 104); this.label4.Name = "label4";

this.label4.Size = new System.Drawing.Size(60, 13); this.label4.TabIndex = 13;

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

// label5 //

this.label5.AutoSize = true;

this.label5.Location = new System.Drawing.Point(468, 104); this.label5.Name = "label5";

this.label5.Size = new System.Drawing.Size(93, 13); this.label5.TabIndex = 14;

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

// label6 //

this.label6.AutoSize = true;

this.label6.Name = "label6";

this.label6.Size = new System.Drawing.Size(125, 13); this.label6.TabIndex = 15;

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

// label7 //

this.label7.AutoSize = true;

this.label7.Location = new System.Drawing.Point(241, 310); this.label7.Name = "label7";

this.label7.Size = new System.Drawing.Size(122, 13); this.label7.TabIndex = 16;

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

// label8 //

this.label8.AutoSize = true;

this.label8.Location = new System.Drawing.Point(468, 310); this.label8.Name = "label8";

this.label8.Size = new System.Drawing.Size(155, 13); this.label8.TabIndex = 17;

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

// label9 //

this.label9.AutoSize = true;

this.label9.Location = new System.Drawing.Point(22, 506); this.label9.Name = "label9";

this.label9.Size = new System.Drawing.Size(73, 13); this.label9.TabIndex = 18;

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

// label10 //

this.label10.AutoSize = true;

this.label10.Location = new System.Drawing.Point(241, 506); this.label10.Name = "label10";

this.label10.Size = new System.Drawing.Size(73, 13); this.label10.TabIndex = 19;

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

// label11 //

this.label11.AutoSize = true;

this.label11.Location = new System.Drawing.Point(468, 506); this.label11.Name = "label11";

this.label11.Size = new System.Drawing.Size(73, 13); this.label11.TabIndex = 20;

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

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

this.textBox10.Size = new System.Drawing.Size(96, 20); this.textBox10.TabIndex = 22;

//

// textBox11 //

this.textBox11.Name = "textBox11";

this.textBox11.Size = new System.Drawing.Size(96, 20); this.textBox11.TabIndex = 23;

//

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

this.richTextBox2.Location = new System.Drawing.Point(244, 120); this.richTextBox2.Name = "richTextBox2";

this.richTextBox2.Size = new System.Drawing.Size(196, 173); this.richTextBox2.TabIndex = 26;

this.richTextBox2.Text = ""; //

// richTextBox3 //

this.richTextBox3.Location = new System.Drawing.Point(471, 120); this.richTextBox3.Name = "richTextBox3";

this.richTextBox3.Size = new System.Drawing.Size(196, 173); this.richTextBox3.TabIndex = 27;

this.richTextBox3.Text = ""; //

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

this.chart1.ChartAreas.Add(chartArea2); legend2.Name = "Legend1";

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.AutoSize = true;

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

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

this.label12.Location = new System.Drawing.Point(23, 9); this.label12.Name = "label12";

this.label12.Size = new System.Drawing.Size(676, 15); this.label12.TabIndex = 32;

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

"OT"; //

// label13 //

this.label13.AutoSize = true;

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

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

this.label13.Location = new System.Drawing.Point(170, 24); this.label13.Name = "label13";

this.label13.Size = new System.Drawing.Size(372, 15); this.label13.TabIndex = 33;

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

this.Controls.Add(this.label13); this.Controls.Add(this.label12); this.Controls.Add(this.chart1); this.Controls.Add(this.txtQuickSort); this.Controls.Add(this.txtStrandSort); this.Controls.Add(this.txtBucketSort); this.Controls.Add(this.richTextBox3); this.Controls.Add(this.richTextBox2); this.Controls.Add(this.richTextBox1); this.Controls.Add(this.button2); this.Controls.Add(this.textBox11); this.Controls.Add(this.textBox10); this.Controls.Add(this.textBox9); this.Controls.Add(this.label11); this.Controls.Add(this.label10); this.Controls.Add(this.label9); this.Controls.Add(this.label8); this.Controls.Add(this.label7); this.Controls.Add(this.label6); this.Controls.Add(this.label5); this.Controls.Add(this.label4); this.Controls.Add(this.label3); this.Controls.Add(this.button1);

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

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.

Wahyudi Bambang. 2004. Struktur Data dan Algoritma. Yogyakarta: Andi Offset. Robert Lafae. 2003. Data Structures and Algoritms in Java, USA:Sams Publishing.

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.

Permasalahan utama dari sistem yang akan dikembangkan pada skripsi ini adalah bagaimana mengembangkan aplikasi untuk mengurutkan data dengan menggunakan Bucket Sort, Strand Sort dan Quick Sort 2 Pivot. Selanjutnya masalah ini diuraikan ke beberapa kategori, antara lain : pengguna sistem, mesin, material dan metode. Dalam hal ini Diagram Ishikawa akan dijelaskan pada Bab 4 yaitu Diagram Ishikawa untuk Impelemtasi.

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

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.

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

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 sedang dirancang sedemikian rupa, bagaimana proses alir datanya, bagaimana proses dan bagaimana akhir dari sebuah sistem.

Gambar 3.4 Diagram Actifity Sistem

3.4.3 Sequence Diagram

Sequence Diagram adalah suatu diagram yang menunjukkan atau menampilkan hubungan-hubungan atau interaksi-interaksi antar setiap objek yang disusun pada suatu urutan atau rangkaian waktu. Interaksi yang dimaksudkan adalah bagaimana hubungan antar pengguna dan sistemnya berlangsung atau biasa disebut bagaimana perilaku user terhadap sistem.

Gambar 3.5 Sequence Diagram Sistem

3.5 Flowchart Sistem

Flowchart adalah sebuah diagram umum yang menggambarkan sebuah proses dari algoritma dengan menggunakan diagram alir data untuk memperlihatkan bagaimana langkah-langkah yang dilakukan program untuk menyelesaikan sebuah masalah.

3.5.1 Flowchart Algoritma Bucket Sort

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

ya

tidak

tidak

ya

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][

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

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)

Selesai Arrange Result

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

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

Data terurut Data terurut Data terurut

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

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) - (12*10)/100=1,2=1 - (22*10)/100=2,2=2 - (24*10)/100=2,4=2 - (1*10)/100=0,1=0 - (5*10)/100=0,5=0 - (21*10)/100=2,1=2 - (23*10)/100=2,2=2 - (5*10)/100=0,5=0 - (2*10)/100=0,2=0 - (3*10)/100=0,3=0

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

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

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

Ket: data yang berwarna merah merupan bagian yang terurut. Proses Strand Sort dilakukan dengan menyisipkan elemen-elemen dari sebelah kanan ketempatnya yang sesuai dibagian terurut (kiri).

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:

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:

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

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

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

Untuk membuat implementasi serta Mengetahui kompleksitas dan running time dari ketiga algoritma tersebut

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

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

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.

a. Bucket sort b. Strand sort c. Quick sort 2 pivot Gambar 4.4 Pengurutan pada Max Item 10 Max Item Value = 1000

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.

Gambar 4.6 Tampilan hasil pada max item 10 dan Max Item Value 1000000 Pada kondisi Max item 10 dan Max Item Value 1000000 dengan data yang diberikan pada ketiga kondisi yang sama maka diperoleh hasil pengurutan seperti pada gambar 4.7 Pada kondisi ini waktu eksekusi tercepat adalah dengan metode strand sort sebesar 4,3 x 10-3 sec, selanjutnya metode quick sort 2 pivot sebesar 4,8 x 10-3 sec, dan yang paling lama adalah bucket sort sebesar 275910,7x 10-3 sec. Pada kondisi ini metode bucket sort memerlukan waktu paling lama untuk eksekusi bila dibandingkan dengan kedua metode lainnya. Dari hasil ini terlihat bahwa tidak ada perbedaan yang signifikan antara strand sort dan quick sort 2 pivot, sedangkan terhadap bucket sort memiliki perbedaan yang sangat signifikan.

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

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.

Gambar 4.8 Grafik perbandingan ketiga pengurutan untuk Max Item 10 Max Item Value = 1000000

4.3.2 Pengurutanpada Max Item = 500

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

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

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.

Gambar 4.11 Grafik perbandingan ketiga pengurutan untuk Max Item 500 Max Item Value = 1000

b. Max Item Value = 1000000

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

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.

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

Max Item Value 1000000

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.

Gambar 4.14 Grafik perbandingan ketiga pengurutan untuk Max Item 500 Max Item Value = 1000000

4.3.3 Pengurutanpada Max Item = 1000

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

Pada kondisi Max item 1000 dan Max Item Value 1000 dengan data yang sama pada ketiga kondisi maka diperoleh hasil pengurutan seperti pada gambar 4.16. Pada kondisi ini waktu eksekusi tercepat adalah metode bucket sort sebesar 114,8 x 10-3 sec, selanjutnya metode uick sort 2 pivot sebesar 474 x 10-3 sec dan metode strand sort sebesar 2654,7 x 10-3 sec. Pada kondisi ini metode strand sort memerlukan waktu paling lama untuk eksekusi bila dibandingkan dengan kedua metode lainnya. Terlihat bahwa metode bucket sort dan quick sort 2 pivot membutuhkan waktu semakin cepat dibandingkan dengan metode strand sort dengan kondisi jumlah data yang semakin besar dan jumlah max item value yang semakin besar juga.

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

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.

Gambar 4.17 Grafik perbandingan ketiga pengurutan untuk Max Item 1000 Max Item Value = 1000

b. Max Item Value = 1000000

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

Gambar 4.18 Pengurutan Pada Max Item 1000 Max Item Value=1000000 Pengurutan pada Max Item = 1000 dilakukan untuk data dengan Max Item Value 1000000. Sedangkan data yang diberikan kepada masing-masing kondisi adalah data dengan bentuk dan jumlah yang sama. Gambar 4.18. Merupakan hasil uji coba pada kondisi ini. Pada kondisi ini waktu eksekusi tercepat adalah dengan metode Quick sort 2 pivot sebesar 1410 x 10-3 sec, selanjutnya yaitu dengan metode Strand sort sebesar 2768,1 x 10-3 sec dan yang paling lambat adalah metode Bucket sort sebesar 160704,7 x 10-3 sec. Pada kondisi ini metode bucket sort memerlukan waktu paling lama untuk eksekusi bila dibandingkan dengan Strand sort dan Quick sort 2 pivot. Dengan Max Item Value yang semakin besar, metode Quick sort 2 pivot masih lebih baik dibandingkan dengan metode strand sort dan sangat-sangat lebih baik daripada Bucket sort untuk data yang semakin banyak. Dari hasil ini juga terlihat bahwa, dengan jumlah data yang semakin besar, metode Bucket sort membutuhkan waktu yang semakin besar dibandingkan dengan metode lain.

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

Max Item Value 1000000

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.

Gambar 4.20 Grafik perbandingan ketiga pengurutan untuk Max Item 1000 Max Item Value = 1000000

4.4 Pembahasan

Pada bagian ini akan dibahas hasil uji coba yang telah dilakukan. Untuk uji coba dengan Max Item 10 dengan Max Item Value 1000 dan 1000000, terlihat perbedaan yang begitu signifikan antara ketiga algoritma yang digunakan. Dan metode strand sort memiliki waktu eksekusi yang lebih baik daripada Quick sort 2 pivot dan Bucket sort, terdapat perbedaan yang sangat tipis antara strand sort dan quick sort 2 pivot, tapi sangat berbeda terhadap Bucket sort.perbedaan tersebut belum terlalu berpengaruh karena jumlah data yang masih kecil.

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.

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

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)

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

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

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)

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

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

Penulis menyarankan untuk Penelitian selanjutnya agar algoritma pengurutan yang dibahas lebih banyak lagi serta menambahkan struktur data lain seperti data stack, single linklist, double linklist disertai dengan simulasi, serta diberikan contoh program atau program simulasi step-by-step untuk memperjelas materi pembahasan dan juga memperhatikan spesifikasi komputer yang lebih rendah maupun tinggi untuk melihat perbedaan yang lebih signifikan untuk masing-masing algoritma.

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.

Algoritma adalah jantung ilmu komputer atau informatika. Banyak cabang ilmu komputer yang diacu dalam terminologi algoritma. Namun, jangan beranggapan algoritma selalu identik dengan ilmu komputer saja. Dalam kehidupan sehari-hari pun banyak terdapat proses yang dinyatakan dalam suatu algoritma. Cara-cara membuat kue atau masakan yang dinyatakan dalam suatu resep juga dapat disebut sebagai algoritma. Pada setiap resep selalu ada urutan langkah-lankah membuat masakan. Bila langkah -langkahnya tidak logis, tidak dapat dihasilkan masakan yang diinginkan. Ibu-ibu yang mencoba suatu resep masakan akan membaca satu per satu langkah-langkah pembuatannya lalu ia mengerjakan proses sesuai yang ia baca. Secara umum, pihak (benda) yang mengerjakan proses disebut pemroses (processor). Pemroses tersebut dapat berupa manusia, komputer, robot atau alat-alat elektronik lainnya. Pemroses melakukan suatu proses dengan melaksanakan atau mengeksekusi algoritma yang menjabarkan proses tersebut(Munir 2007).

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.

2. Metode pengurutan tidak stabil (non stable sorting algorithm), merupakan metode pengurutan yang tidak menjaga/mempertahankan (maintenance) urutan dari beberapa elemen array yang bernilai sama. Dengan kata lain, urutan beberapa elemen yang sama berbeda antara sebelum dan sesudah pengurutan. Algoritma memiliki dua skema, yaitu iteratif dan rekursif. Iteratif yaitu algoritma yang melakukan perulangan biasa, sedangkan rekursif adalah algoritma yang

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

Kinerja sebuah algoritma biasanya di ukur dengan mengacu pada kondisi terburuknya, yaitu worst case yang dilambangkan dengan notasi Big O. Notasi Big O adalah fungsi yang berkaitan dengan kelajuan proses dan kelajuan pertambahan data (Suryani 2013).

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

O(2cn) Dobel Eksponensial Pencarian himpunan lengkap dari AC-unifiers (associative-commutative unifiers)

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

Algoritma Bucket Sort merupakan salah satu bentuk algoritma devide & conguer melalui metode partisi dan berjalan dalam keadaan linier time (Wilkinson & Allen, 2005). Secara teoritis proses pengurutan dilakukan dengan membagi dan memecahkan himpunan array kedalam beberapa ember virtual secara merata. Algoritma devide and conguer sudah lama diperkenalkan sebagai sumber dari pengendali proses paralel, karena masalah-masalah yang terjadi dapat diatasi secara independen. Banyak arsitektur dan bahasa pemrograman paralel mendesain implementasinya (aplikasi) dengan struktur dasar dari algoritma devide & conguer. Devide and conguer adalah varian dari beberapa strategi pemrograman top down, tetapi yang paling istimewa dalam hal ini adalah dengan membuat sub-sub problem dari problem yang besar, oleh karena itu strategi ini ditunjukkan secara berulang-ulang (rekursiv). Sebagaimana disebutkan algoritma perulangan, dibutuhkan sebuah kondisi untuk mengakhiri perulangan tersebut. Biasanya untuk mengecek apakah problem sudah cukup kecil untuk diselesaikan dengan metodenya langsung.

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

{

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:

1. Sederhana dalam penerapannya. 2. Prosesnya cepat dalam data yang kecil.

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;

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

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

Sebaliknya setelah kita mengetahui worst case O(n) algoritma seleksi tersedia, kita dapat menggunakannya untuk mencari pivot ideal (median) pada setiap langkah quicksort, yang menghasilkan ragam kalkulasi waktu worst case O(n log n). Pada implementasi praktiknya, bagaimanapun, varian ini dianggap lebih lambat dari rata-rata. Pada setiap versi awal quicksort, elemen yang paling kiri dari partisi akan sering

vi

ABSTRAK

Pengurutan data merupakan proses untuk menyusun kembali data yang sebelumnya disusun dengan suatu pola tertentu sehingga akan tersusun secara teratur untuk memudahkan proses dalam pencarian data. Dengan adanya algoritma pengurutan ini, data yang awalnya disusun secara acak akan menjadi terurut sesuai dengan aturan tertentu. Ada banyak metode untuk sorting data, namun pada tugas akhir ini akan dibahas metode Bucket sort adalah algoritma yang membagi dan memecahkan himpunan array ke dalam beberapa tempat yang biasa disebut dengan istilah Bucket secara merata. Algoritma strand sort adalah algoritma yang bertujuan untuk menjadikan bagian sisi kiri array terurutkan sampai dengan seluruh array berhasil diurutkan. Algoritma Quick sort 2 Pivot merupakan algoritma pengurutan data yang menggunakan pemecahan data menjadi partisi-partisi dengan implementasi menggunakan bahasa pemrograman C#. Analisis kinerja algoritma ini bertujuan untuk mengetahui Kompleksitas algoritma dan running Time dari ketiga algoritma tersebut. Kompleksitas waktu dapat dihitung melalui tahapan pengurutan yang diketahui berdasarkan langkah-langkah algoritma tersebut dalam memecahkan masalah dan running Time algoritma yang dihitung berdasarkan platform yang digunakan. Dalam percobaan yang dilakukan terdapat kelebihan dan kekurangan dari masing-masing algoritma yang dipengaruhi oleh banyak data yang diurutkan.

Kata kunci: Pengurutan, Bucket Sort, Strand Sort, Quick Sort 2 Pivot, Kompleksitas waktu, running time.

vii

IMPLEMENTATION AND ANALYSIS ALGORITHM BUCKET SORT, STRAND SORT AND QUICK SORT 2 PIVOT

IN DATA SORTING

ABSTRACT

Sorting is a process to rearrange the data that arranged before are certain a pattern that will contain regularly to facilitate the search data. By this sorting algorithm, the data that served randomly can be arranged by regular. Sorting algoritm use in this research are: Bucket Sort, Strand Sort and Quick Sort 2 Pivot. Bucket sort is algoritm that use Splitting and Solve compilation an array in bucket virtual in equally. Strand sort is algorithm that make a left array are sorting until all of array finished to sorting. Quick sort 2 Pivot algoritm is data sorting algoritm that use Splitting data into partitions. Programing language implementation use C#. 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. In this Experiment conducted there are the advantages and disadvantages of each the algoritms that influenced by a lot of data is sorted.

Keywords : Sorting, Bucket Sort, Strand Sort, Quick Sort 2 Pivot, Time Complexity, running time

viii

DAFTAR ISI

Halaman

Persetujuan ii

Pernyataan iii

Penghargaan iv

Abstrak vi

Abstract vii

Daftar Isi viii

Daftar Tabel x

Daftar Gambar 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 Penelitian 4

Bab 2 Landasan Teori

2.1. Pengertian Algoritma 5

..2.2. Algoritma Pengurutan (Sorting) 5

. 2.3. Kompleksitas Algoritma 7

2.4. Growth Function 7

2.5. Notasi Asimptotik 8

2.6. Algoritma Bucket Sort 9

2.6.1.Pseudocode Algoritma Bucket Sort 10

2.7. AlgoritmaStrand Sort 10

2.7.1.Pseudocode Algoritma Strand Sort 12

2.8. Algoritma Quick Sort 2 Pivot 12

2.8.1. Pseudocode Algoritma Quick Sort 2 Pivot 14

2.9. Struktur Data 14

2.9. Penelitian Terdahulu 16

Bab 3 Analisis dan Perancangan Sistem

3.1. Analisis Sistem 17

.3.1.1 Analisis Masalah 17

3.2.Analisis kebutuhan sistem 18

3.2.1Kebutuhan fungsional 18

3.2.2Kebutuhan non fungsional 18

ix

3.4.3. SequenceDiagram 21

3.5. Flowchart Sistem 22

3.5.1.Flowchart Algoritma Bucket Sort 23

3.5.2.Flowchart Algoritma Strand Sort 24

3.5.3.Flowchart Algoritma Quick Sort 2 Pivot 25

3.6. Alur Proses Sistem 26

3.6.1. Alur Proses Algoritma Bucket Sort 26

3.6.1.1. Proses Algoritma Bucket Sort 27

3.6.2. Alur Proses Algoritma Strand Sort 28

3.6.2.1. Contoh Proses Algoritma Strand Sort 28 3.6.3. Alur Proses Algoritma Quick Sort 2 Pivot 30 3.6.3.1. Proses Algoritma Quick Sort 2 Pivot 30 Bab 4 Implementasi Sistem

4.1. Pendahuluan 32

4.2. Generate Data 32

4.3. Hasil Uji Coba 33

.4.3.1. Pengurutan pada Max item=10 33

4.3.2. Pengurutan Max item=500 36

4.3.3. Pengurutan Max item=1000 39

4.4. Pembahasan 43

4.5.Hasil Penghitungan Kompleksitas Big Tetha (�) 44 4.5.1.Hasil Penghitungan Big Tetha (�)Bucket Sort 44 4.5.2.Hasil Penghitungan Big Tetha (�)Strand Sort 45 4.5.3.Hasil Penghitungan Big Tetha (�)Quick Sort 2 Pivot 46 Bab 5 Penutup

5.1. Kesimpulan 48

5.2. Saran 48

Daftar Pustaka Lampiran

x

DAFTAR TABEL

Nomor

Tabel Nama Tabel Halaman

1.1 1.2 4.1 4.2

Tabel Notasi Big O

Perbedaan Mendetail antara Array dan List

Tabel Penghitungan Big Tetha Algoritma Bucket Sort Tabel Penghitungan Big Tetha Algoritma Strand Sort

7 16 44 45

xi

DAFTAR GAMBAR

Nomor

Gambar Nama Gambar Halaman

3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10 4.11 4.12 4.13 4.14 4.15 4.16 4.17 4.18 4.19 4.20 Diagram Ishikawa

Bentuk Dari Sorting Data Use Case Diagram Diagram Activity Sistem Sequence Diagram Sistem Flowchart Algoritma Bucket Sort Flowchart Algoritma Strand Sort

Flowchart Algoritma Quick Sort 2 Pivot Gambar Algoritma Bucket Sort

Gambar Algoritma Strand Sort

Diagram Ishikawa untuk Implementasi Penelitian Tampilan Utama Sorting data

Item Tampilan hasil pada max item=10 dan max item value =1000

Pengurutan pada max item=10 dan max item value =1000 Grafik perbandingan ketiga pengurutan untuk max item=10 dan max item value =1000

Item Tampilan hasil pada max item=10 dan max item value =1000000

Pengurutan pada max item=10 dan max item value =1000000 Grafik perbandingan ketiga pengurutan untuk max item=10 dan max item value =1000000

Pengurutan pada max item=500 max item value=1000 Hasil Pengurutan pada max item=500 dan max item value=1000

Grafik perbandingan ketiga pengurutan untuk max item=500 dan max item value =1000

Pengurutan pada max item=500 dan max item value=1000000 Hasil Pengurutan pada max item=500 dan max item

value=1000000

Grafik perbandingan ketiga pengurutan untuk max item=500 dan max item value =1000000

Pengurutan pada max item=1000 dan max item value=1000 Hasil Pengurutan pada max item=1000 dan max item value=1000

Grafik perbandingan ketiga pengurutan untuk max item=1000 dan max item value =1000

Pengurutan pada max item=1000 dan max item value=1000000 Hasil Pengurutan pada max item=1000 dan max item

value=1000000

Grafik perbandingan ketiga pengurutan untuk max item=1000 dan max item value =1000000

18 19 20 21 22 23 24 25 27 28 32 33 34 34 35 35 36 36 37 37 38 38 40 40 40 41 41 42 43 43