1

Analisis Pengurutan Data menggunakan Metode

Selection Sort, Shell Sort dan Binary Insertion
Sort
Ervina Dika Tria Puspitasari. NIM 17702251011. Program Studi Pendidikan Teknologi dan Kejuruan.
Program Pascasarjana. Universitas Negeri Yogyakarta. Email: ervinadikatriap.2017@student.uny.ac.id

secara sederhana dengan cara mencari data terkecil

Abstrak — Metode sorting merupakan metode atau dari susunan data awal, data pertama sampai data
cara untuk mengurutkan data yang tersusun. Banyak terakhir. Setelah data terkecil ditemukan kemudian
metode sorting dalam pengurutan data. Pada paper ini tukarkan degan data pertama. Setelah itu dicari data
akan difokuskan mengurutkan data menggunakan
metode Selection Sort, Shell Sort dan Binary Insertion terkecil, mulai kembali dari data kedua sampai data
Sort. Mengimplementasikan ketiga jenis metode terakhir. Setelah di dapatkan kemudian data tersebut
sorting tersebut dan melihat performance process dari ditukarkan dengan data kedua, sampai proses
Selection Sort, Shell Sort dan Binary Insertion Sort. seterusnya hingga memperoleh data urut dari awal
Pada tahap pertama masukkan jumlah data pada sampai akhir.
bentuk coding dengan menggunakan bahasa
pemrograman C++, kemudian tahap kedua compile
program maka akan terlihat seberapa cepat atau Contoh penggurutan data dengan metode Selection
lambat performa proses dari metode sorting yang Sort
diimplemetasikan, tahap ketiga running program dan
akan terlihat hasil dari susunan data yang telah Data awal diperoleh angka
disusun berdasarkan metode sorting. Dari ketiga hasil
sorting bahwa Selection Sort dan Shell Sort memiliki
40 80 20 50 70 30 60
performa yang lebih baik dibandingkan dengan
Binary Insertion Sort. Dan untuk Selection Sort selain
memiliki performa proses yang lebih baik, metode
tersebut adalah metode paling sederhana untuk Cari data terkecil dari data pertama sampai
mengurtkan data. terakhir, ditemukan data 20 sebagai angka terkecil
pada urutan ke lima. Tukarkan data tersebut dengan
Kata kunci: Sorting, Selection Sort, Shell Sort, data 40 di urutan pertama, sehingga hasilnya
Binary Insertion Sort. menjadi seperti dibawah ini:
I. PENDAHULUAN
20 80 40 50 70 30 60
Pengurutan (sorting) merupakan proses untuk
menrutkan data dengan aturan atau prosedur dan
langkah-langkah tertentu, sehingga data yang Selanjutnya mencari data terkecil mulai dari
disusun dapat tersusun sesuai dengan prosedur. urutan data kedua sampai terakhir. Ditemukan data
Sorting memiliki dasar pengurutan dari data 30 diurutan ke enam, kemudian tukarkan data 30
minimal ke maksimal (ascending) dan pengurutan dengan 80 di urutan kedua sehingga hasilnya:
data dari maksimal ke data minimal descending).
Proses yang terjadi pada pengurutan data sorting 20 30 40 50 70 80 60
adalah proses perbandingan dan pertukaran data.
Pada sorting data yang telah terurut Cari kembali data terkecil mulai dari urutan data
mempermudah dalam proses pencarian, proses ketiga. Ditemukan data 40 yang sudah berada di
pemeriksaan dan proses perbaikan data jika pada urutan ke ketiga, sehingga tidak terjadi pertukaran
pengurutan tersebut terjadi suatu kesalahan. posisi dengan data yang lainnya.
Penggunaan sorting memberikan kemudahan untuk Kemudian untuk pencarian data terkecil keempat
menyisipkan data ataupun penggabunga data. hasilnya samaseperti saat pencarian data terkecil
ketiga dimana data 50 sudah berada pada urutan
II. PEMBAHASAN
keempat dan tidak mengalami pertukaran posisi
A. Metode Selection Sort
dengan data lainnya.
Pengurutan data dengan menggunakan metode
Berikutnya mencari data terkecil dari urutan
Selection Sort merupakan metode pengurutan data
 2

kelima. Ditemukan data 60 di urutan terakhir. Yang dikurangi 1 (n/4).

kemudian ditukarkan dengan data urutan ke lima 7. Pilih semua elemen mulai dari posisi pertama
sehingga hasilnya: dan bandingna dengan emelen dalam jarak
gap.
20 30 40 50 60 80 70 8. Gap berkurang menjadi 0, pemilihan data
berhenti dan data sudah diurutkan.
Pencarian data terkecil terakhir dimulai dari urutan Untuk lebih jelas dapat disajikan pada gambar
data keenam, dimana data terakhir yaitu 70, berikut:
kemudan ditukar dengan 80 yang berada pada urutan
ke enam, sehingga hasilnya:

20 30 40 50 60 70 80

Data diatas diurutkan berdasarkan pengurutan data

dari mulai terkecil hinggal terbesar (ascending).
Untuk mendapatkan urutan data yang sebaliknya,
maka perlu diurutkan degan mengganti data mulai
dari angka yang terbesar.

B. Metode Shell Sort

Metode Shell Sort merupakancara untuk
mengurutkan data menggunakan cara dimana
susunan data dibagi menjadi beberapa bagian
dengan jarak tertentu dan kemudian disusun
menjadibentuk baris atau kolom. Dari setiap kolom
tersebut kemudian data diurutkan. Apabila
jumlahnya ganjil maka yang terakhir merupakan sisa
dari pembagian jarak tersebut.
Contoh penggurutan data dengan metode Shell
Sort
Diperoleh data awal sebagai berikut:

Gambar 2. Analogi hasil urutan data menggunakan

Gambar 1. Analogi urutan data menggunakan
metode Shell Sort
Dari data tersebut dapat diurutkan dengan metode
Shell Sort dengan langkah sebagai berikut:
1. Dimulai dari gap = n/2 (dalam artian pada
kasus ini adalah dibagi menjadi dua
kelompok)
2. Satu persatu elemen dipilih diseblah kanan
pada celah untuk mendapatkan data pada
posisi yang tepat.
3. Elemen kiri dari 54 sudah lebih kecil, jadi
tidak ada perubahan. Satu persatu elemen
dipiluh di sebalah kanan untuk mendapatkan
posisi yang tepat.
4. Membandingkan 2 dengan data pada posisi
kedua (urutan ke 3-1) yaitu 34 dan geser ke
posisi ke 3.
5. Membandingkan 2 dengan 34 dan kemudian
geser ke posisi ketiga.
6. Terjadi pertukaran data, kemudian gap
metode Shell Sort
C. Metode Binary Insertion Sort
Pengurutan data dengan menggunakan metode
Binary Insertion Sort merupakan metode untuk
membandingkan data padakelompok data yang telah
dibagi menjadi dua bagian dari susunan data yang
telah urut sebelumnya. Metode ini merupakan
metode untuk memperbaiki metode Straight
Insertion yang dimana pada metode tersebut hanya
membandingkan data saja.
Contoh pengurutan data dengan metode Binary
Insertion Sort
Diperoleh data awal:
30 70 10 40 60 20 50
Langkah yang pertama adalah membaca data
pertama, dipeorleh hasil seperti diatas. Kemudian
membaca data kedua dan masih tersusun dalam
urutan yang sama. Baca data ketiga, data pertama
 3

dan kedua yang telah diurutkan dibagi menjadi dua #include<iomanip>

bagian yaitu 30 dan 70 dan data 10 dibandingkan #include<conio.h>
dengan data 30 yang lebih memungkinkan dimana
data 10 ke posisi pertama dan menggeser data 30 dan void selectionSort(int
70 berubah ke posisi kanan, dengan hasil sebagai array[], const int size)
berikut:
{
10 30 70 40 60 20 50 int i, j, kecil, temp;
for(i=0; i<size; i++)
Berikutnya baca data keempat. Data yyang telah urut {
sebelumnya dibagi menjadi dua kelompok bagian kecil=i; for (j=i+1;
yaitu (10 dan 30) dan data 70. Data 40 lebih tepat j<size; j++)
dibandingkan dengan 70, sehingga kelompok data {
(10 dan 30) bisa di abaikan. Sisipkan data 40 ke if (array
urutan ketiga dan geser data 70 ke sebalah kanan [kecil]>array[j])
diurutan ke empat. Hasilnya dapat dilihat sebagai {
berikut: kecil=j;
}
}
10 30 40 70 60 20 50
temp=array[i];
array[i]=array [kecil];
Kemudian baca data kelima, bagi terlebih dahulu
array[kecil]=temp;
menjadi dua bagian data yang telah urut sebelumnya
}
yaitu (10 dan 30) dan (40 dan 70). Emungkinan data
}
60 disisipkan ke pada kelompok 40 dan 70, sehingga int main()
kelompok 10 dan 30 dapat diabaikan. Bagi {
kelompok 40 dan 70 menjadi dua bagian, sisipkan int
angka 60 pada urutan ke empat, dengan hasil: NumList[5]={31,34,87,65,90};
cout<<"SELECTION
10 30 40 60 70 20 50 SORT"<<endl;
Untuk data keenam diperoleh angka 20. Setelah data cout<<"=====================
diurutkan menjadi dua kelompok yaitu (10 30 40) ==========="<<endl;
dan (60 70), maka kemungkinan data 20 masuk cout<<"Data Sebelum
dalam kelompok (10 30 40), sisipkan data 20 pada Diurutkan: \n";
posisi diatas 10 karena 20 lebih besar daripada 10, for(int d=0; d<5; d++)
setelah di bandingkan akan di peroleh hasil: {
cout<<setw(3)<<NumList[d];
10 20 30 40 60 70 50 }
cout<<"\n ";
Data yang telah diurutkan sebelumnya dibagi selectionSort(NumList, 5);
menjadi dua bagian, yaitu kelompok (10 20 30) dan cout<<"Data Sesudah
(40 60 70). Abaikan kelompok yang datanya Diurutkan \n\n " ;
dibawah angka 50, berati yang dipilih adalah for(int iii=0; iii<5;
kelompok 40 60 70. Maka bandingkan angka 50 iii++)
dengan kelompok tersebut dan sisipkan di setelah {
angka data 40, maka akan menggeser data 60 dan 70
keposisi sebelah kanan, dengan hasil: cout<<setw(3)<<NumList[iii];
}
10 20 30 40 50 60 70 }

Hasil sudah menunjukkan sorting dengan pengurtan 2. Hasil performance compile program
data terkecil ke terbesar (ascending).

III. IMPLEMENTASI DAN PENGUJIAN

A. Selection Sort
1. Program Selection Sort untuk lima data
masukan.
#include<iostream> Gambar 3. Performance Process Selection
using namespace std; Sort 5 data.
 4

3. Hasil program saat dijalankan (running cout<<"Data Sebelum

program) Diurutkan: \n";
for(int d=0; d<25; d++)
{
cout<<setw(3)<<NumList[d];
}
cout<<"\n ";
selectionSort(NumList, 25);
cout<<"Data Sesudah
Diurutkan \n\n " ;
for(int iii=0; iii<25;
iii++)
{

cout<<setw(3)<<NumList[iii];
}
Gambar 4. Hasil Running Program
}
Selection Sort dengan data sebanyak 5
data.

4. Program Selection Sort untuk dua puluh

lima data masukan. 5. Hasil performance compile program

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

void selectionSort(int
array[], const int size)

{ Gambar 5. Performance Process Selection

int i, j, kecil, temp; Sort 25 data.
for(i=0; i<size; i++)
{ 6. Hasil program saat dijalankan (running
kecil=i; for (j=i+1; program)
j<size; j++)
{
if (array
[kecil]>array[j])
{
kecil=j;
}
}
temp=array[i];
array[i]=array [kecil]; Gambar 6. Hasil Running Program
array[kecil]=temp; Selection Sort untuk 25 data.
}
} Data setelah di urutkan adalah:
int main() 11, 12, 23, 31, 31, 32, 34, 34, 34, 43, 45,
{ 45, 46, 54, 56, 65, 65, 67, 77, 87, 87, 89,
int 90, 90, 98.
NumList[25]={31,34,87,65,90,
87,56,43,90,77,11,23,45,65,1 7. Program Selection Sort untuk lima puluh
2,45,32,46,89,67,54,31,34,98
(50) data masukan.
,34};
cout<<"SELECTION #include<iostream>
SORT"<<endl; using namespace std;
#include<iomanip>
cout<<"===================== #include<conio.h>
==========="<<endl;
 5

void selectionSort(int 8. Hasil performance compile program

array[], const int size)

{
int i, j, kecil, temp;
for(i=0; i<size; i++)
{
kecil=i; for (j=i+1;
j<size; j++)
{
if (array Gambar 7. Performance Process Selection
[kecil]>array[j]) Sort 50 data.
{
kecil=j; 9. Hasil program saat dijalankan (running
} program)
}
temp=array[i];
array[i]=array [kecil];
array[kecil]=temp;
}
}
int main()
{
int
NumList[50]={31,34,87,65,90,
87,56,43,90,77,11,23,45,65,1
2,45,32,46,89,67,54,31,34,98
,34,21,23,43,55,46,78,98,76,
45,33,12,13,14,16,89,91,23,1 Gambar 8. Hasil Running Program
8,56,43,89,10,57}; Selection Sort 50 data.
cout<<"SELECTION
SORT"<<endl; Hasil data setelah diurutkan:
10, 11, 12, 12, 13, 14, 16, 18, 21, 23, 23,
cout<<"===================== 23, 31, 31, 32, 33, 34, 34, 34, 43, 43, 43,
==========="<<endl; 45, 45, 45, 46, 54, 55, 56, 57, 65, 67, 76,
cout<<"Data Sebelum 77, 78, 87, 89, 89, 90, 90, 91, 98, 98
Diurutkan: \n";
for(int d=0; d<50; d++) B. Shell Sort
{ 1. Program Shell Short dengan jumlah
cout<<setw(3)<<NumList[d]; data sebanyak lima (5).
}
cout<<"\n "; #include <iostream>
selectionSort(NumList, 50); using namespace std;
cout<<"Data Sesudah
Diurutkan \n\n " ; int shellSort(int arr[],
for(int iii=0; iii<50; int n)
iii++) {
{ for (int gap = 5/2;
gap > 0; gap /= 2)
cout<<setw(3)<<NumList[iii]; {
}
} for (int i = gap;
i < 5; i += 1)
{

int temp =
arr[i];

int j;
 6

for (j = i; j
>= gap && arr[j - gap] >
temp; j -= gap)
arr[j] =
arr[j - gap];

arr[j] = temp;
}
}
return 0; Gambar 10. Hasil Running Program Shell Sort
} 5 data.

void printArray(int arr[], 4. Program Shell Sort dengan jumlah data

int n) sebanyak dua puluh lima (25)
{
for (int i=0; i<5; #include <iostream>
i++)
cout << arr[i] << using namespace std;
" ";
}

int main() int shellSort(int arr[], int n)

{
int arr[5] = {30, 49, {
65,11,77}, i;
int n = for (int gap = 25/2; gap
sizeof(arr)/sizeof(arr[0] > 0; gap /= 2)
);
{
cout << "Sebelum
disusun: \n"; for (int i = gap; i <
printArray(arr, 5); 25; i += 1)
shellSort(arr, 5); {
cout << "\nSetelah int temp = arr[i];
disusun: \n";
printArray(arr, 5);

return 0;
}
int j;
2. Hasil performance compile program
for (j = i; j >=
gap && arr[j - gap] > temp; j
-= gap)

arr[j] = arr[j
- gap];

arr[j] = temp;
Gambar 9. Performance Process Shell Sort 5
data.
}

return 0;
3. Hasil program saat dijalankan (running
}
program)
 7

void printArray(int arr[], int

n)

for (int i=0; i<25; i++)

cout << arr[i] << " ";

} Gambar 11. Hasil Running Program Shell Sort

25 data.

7. Program Shell Short dengan jumlah data

int main() sebanyak lima puluh (50).

{ #include <iostream>
using namespace std;
int arr[25] =
int shellSort(int arr[], int n)
{30,49,65,11,77,43,98,65,12,1
{
0,11,43,95,30,65,71,24,36,45,
for (int gap = 50/2; gap
96,61,13,27,72,21}, i;
> 0; gap /= 2)
{
int n =
sizeof(arr)/sizeof(arr[0]);
for (int i = gap; i <
50; i += 1)
cout << "Shell Sort data {
sebelum disusun: \n";
int temp = arr[i];
printArray(arr, 25);

shellSort(arr, 25); int j;

for (j = i; j >= gap
cout << "\nShell Sort && arr[j - gap] > temp; j -=
data setelah disusun: \n"; gap)
arr[j] = arr[j
printArray(arr, 25); - gap];

return 0; arr[j] = temp;

}
} }
return 0;
5. Hasil performance Shell Sort 25 data }

void printArray(int arr[], int

n)
{
for (int i=0; i<50; i++)
cout << arr[i] << " ";
}

int main()
Gambar 11. Performance Process Shell Sort 25 {
Data int arr[50] =
{30,49,65,11,77,43,98,65,12,10,
11,43,95,30,65,71,24,36,45,96,6
6. Hasil program saat dijalankan (running 1,13,27,72,21,12,45,86,97,65,83
program) ,98,35,75,89,13,31,25,16,69,65,
45,11,22,35,67,98}, i;
 8

int n = return
sizeof(arr)/sizeof(arr[0]); binarySearch(a, item, mid+1,
high);
cout << "Shell Sort data return binarySearch(a,
sebelum disusun: \n"; item, low, mid-1);
printArray(arr, 50); }
void insertionSort(int a[],
shellSort(arr, 50); int n)
{
cout << "\nShell Sort data int i, loc, j, k,
setelah disusun: \n"; selected;
printArray(arr, 50);
for (i = 1; i < 5; ++i)
return 0; {
} j = i - 1;
selected = a[i];
8. Hasil performance compile program

loc = binarySearch(a,
selected, 0, j);

while (j >= loc)

{
a[j+1] = a[j];
j--;
}
Gambar 12. Performance Process Shell Sort a[j+1] = selected;
50 data. }
}

9. Hasil program saat dijalankan (running int main()

program) {
int a[5] =
{37,23,76,12,31};
int n =
sizeof(a)/sizeof(a[0]), i;

insertionSort(a, n);

printf("BINARY INSERTION
SORT: \n");
Gambar 14. Hasil Running Program Shell for (i = 0; i < 5; i++)
Sort 50 Data printf("%d ",a[i]);

C. Binary Insertion Sort return 0;

1. Program Binary Insertion Sort untuk }
jumlah data sebanyak lima (5)
2. Hasil performance compile program
#include <stdio.h>

{
if (high <= low)
return (item >
a[low])? (low + 1): low;

int mid = (low + high)/2;

Gambar 15. Performance Process Binary
if(item == a[mid]) Insertion Sort 5 data.
return mid+1;
if(item > a[mid])
 9

3. Hasil program saat dijalankan (running j--;

program) }
a[j+1] = selected;
}
}

int main()
{
int a[25] =
Gambar 15. Running Program Binary {31,34,87,65,90,87,56,43,90,
Insertion Sort 5 data. 77,11,23,45,65,12,45,32,46,8
9,67,54,31,34,98,34};
Data sebelum diurutkan = 37, 23, 76, 12, 31 int n =
Data setelah diurutkan = 12, 23, 31, 37, 76 sizeof(a)/sizeof(a[0]), i;

4. Program Binary Insertion Sort untuk insertionSort(a, n);

jumlah data sebanyak dua puluh lima (25)
printf("BINARY INSERTION
SORT: \n");
#include <stdio.h> for (i = 0; i < 25; i++)
printf("%d ",a[i]);
int binarySearch(int a[], int
item, int low, int high) return 0;
{ }
if (high <= low)
return (item > 5. Hasil performance compile program
a[low])? (low + 1): low;

int mid = (low + high)/2;

if(item == a[mid])
return mid+1;

if(item > a[mid])

return Gambar 16. Performance Process Binary
binarySearch(a, item, mid+1, Insertion Sort 25 data.
high);
return binarySearch(a,
item, low, mid-1); 6. Hasil program saat di jalankan (running
} program)

void insertionSort(int a[],

int n)
{
int i, loc, j, k,
selected;

for (i = 1; i < 25; ++i) Gambar 17. Hasil Running Program Binary
{ Insertion Sort 25 data.
j = i - 1;
selected = a[i]; Data sebelum diurutkan =
31, 34, 87, 65, 90, 87, 56, 43, 90, 77, 11, 23,
45, 65, 12, 45, 32, 46, 89, 67, 54, 31, 34, 98,
loc = binarySearch(a, 34
selected, 0, j); Data setelah diurutkan =
11, 12, 23, 31,31, 32, 34, 34, 34, 43, 45, 45,
while (j >= loc)
46, 54, 55, 65, 65, 67, 77, 87, 87, 89, 90, 90,
{
98
a[j+1] = a[j];
 10

7. Program Binary Insertion Sort untuk 77,11,23,45,65,12,45,32,46,8

jumlah data sebanyak lima puluh (50) 9,67,54,31,34,98,34,30,49,65
,11,77,43,98,65,12,10,11,43,
95,30,65,71,24,36,45,96,61,1
#include <stdio.h> 3,27,72,21};

int binarySearch(int a[], int int n =

item, int low, int high) sizeof(a)/sizeof(a[0]), i;
{
insertionSort(a, n);
if (high <= low)
return (item > printf("BINARY INSERTION
a[low])? (low + 1): low; SORT: \n");
for (i = 0; i < 50; i++)
int mid = (low + high)/2; printf("%d ",a[i]);

if(item == a[mid])
return mid+1; return 0;
}
if(item > a[mid])
return 8. Hasil performance compile program
binarySearch(a, item, mid+1,
high);
return binarySearch(a,
item, low, mid-1);
}

void insertionSort(int a[],

int n)
{
Gambar 18. Performance Process Binary
Insertion Sort 50 data.
int i, loc, j, k,
selected;
9. Hasil program saat dijalankan (running
program)
for (i = 1; i < 50; ++i)

j = i - 1;
selected = a[i];

loc = binarySearch(a,
selected, 0, j); Gamabr 19. Running Program Binary
Insertion Sort 50 data telah diurutkan.
while (j >= loc)
{ Data sebelum diurutkan = 31, 34, 87, 65,
a[j+1] = a[j]; 90, 87, 56, 43, 90, 77, 11, 23, 45, 65, 12, 45,
j--; 32, 46, 89, 67 , 54, 31, 34, 98, 34, 30, 49,
} 65, 11, 77, 43, 98, 65, 12, 10, 11, 43, 95, 30,
a[j+1] = selected; 65, 71, 24, 36, 45, 96, 61, 13, 27, 72, 21
}
} Data sesudah dirutkan = 10, 11, 11, 11, 12,
12, 13, 21, 23, 24, 27, 30, 30, 31, 31, 32, 34,
34, 34, 36, 43, 43, 43, 45, 45, 45, 46, 46, 49,
int main() 54, 56, 61, 65, 65, 65, 65, 65, 65, 67, 71, 72,
{ 77, 77, 87, 87, 89, 90, 90, 95, 96, 98. 98
int a[50] =
{31,34,87,65,90,87,56,43,90,
 11

IV. ANALISIS HASIL IMPLEMENTASI Dari Gambar 22 dapat dianalisis bahwa hasil
performance dari Algoritma Binary
A. Selection Sort Insertion Sort memiliki perbedaan dengan
t analisis Algoritma Selection Sort dan Shell
Sort. Untuk Algoritma Binary Insertion Sort
semakin banyak jumlah data yang
dimasukkan maka hasil performance saat
program di proses akan semakin
membutuhkan waktu yang lama.

D. Perbandingan Performance

data

Gambar 20. Chart Performance Selection

Sort.

Dari Gambar 20 dapat dianalisis bahwa pada

program Selection Sort semakin besar
jumlah data maka waktu atau performance
process program pada saat di compile akan
semakin cepat waktu yang diperlukan.
Gambar 23. Perbandingan kecepatan waktu
B. Shell Sort compile (performance process).
t
Waktu Proses (detik)
Banyaknya
5 25 50
Data
14,48 4,43 2
Selection
detik detik detik
7,7 5,27 3,66
Shell
detik detik detik
0,45 0,48 4,19
data Binary
detik detik detik
Tabel 1. Hasil Perbandingan Waktu
Gambar 21. Chart Performance Shell Sort. Proses (performance process) dari
metode sorting Selection Sort, Shell Sort,
Dari Gambar 21 dapat dianalisis bahwa pada dan Binary Insertion Sort.
program Shell Sort tidak berbeda dengan
performance proces waktu compile
program dari algortitma Selection Sort yaitu V. KESIMPULAN
semakin besar jumlah data maka waktu Dari ketiga algortima yang sudah di jalankan
pemrosesan data akan semakin cepat. menggunakan aplikasi pemrograman DEV C++
dapat disimpulkan bahwa metode sorting
C. Binary Insertion Sort merupakan suatu proses dimana susunan data
t yang semula pada kondisi acak dapat diurutkan
dengan beberapa metode sorting khususnya
metode Selection Sort, Shell Sort dan Binary
Sort, untuk mengurutkan data dari milai terkecil
(minimun) ke data yang terbesar (maksimum).
Analisis dari performance compile program
untuk metode sorting dengan menggunakan
Selection Sort dan Shell Sort memiliki kesamaan,
yaitu semakin banyak jumlah data yang
data dimasukkan untuk di urutkan maka waktu
compiling data akan semakin cepat. Berbeda
Gambar 22. Chart Performance Binary dengan metode sorting Binary Insertion Sort,
Insertion Sort. semakin banyak jumlah data yang dimasukkan
untuk di urutkan maka waktu yang dibutuhkan
akan semakin lama meskipun waktu yang
 12

dibutuhkan dalam implementasi diatas adalah

dengan waktu berkisar tidak lebih dari 1 detik.
Dari ketiga metode sorting tersebut dapat
disimpulkan bahwa penggunaan metode
Selection Sort dan Shell Sort adalah metode yang
lebih efisien untuk digunakan karena selain
waktu compile yang berpengaruh pada
performance process data, apabila semakin
banyak jumlah data maka waktu yang
dibutuhkan semakin cepat dan terdapat juga
kemudahan dalam pertukaran datanya, selain itu
dapat dikatakan juga bahwa metode Selection
Sort adalah metode yang paling sederhana
dalam pengerjaannya dikarenakan metode ini
mengurutkan dengan cara mencari data terkecil
dari susunan awal sampai terakhir, setelah data
terkecil ditemukan kemudian di tukarkan dengan
data pertama, begitu terus seterusnya hingga
tersusun data sesuai dengan tujuan sorting data
(ascending ke descending).

VI. REFERENSI

[1] Audy. (2015). Komparasi Algoritma Quick Sort dan Bucked

Sort pada Pengurutan Data Integer. Jurnal Program Studi
Teknik Informatika. Universitas Multimedia Nusantara.
Jakarta.
[2] Binary Insertion Sort
http://geeksforgeeks.org/ di akses pada tanggal 7 November
2017
[3] Saptadi, Arief H., Sari, Dewi Windi. Analisis Algortima
Insertion, Merge Sort dan Implementasinya Dalam Bahasa
Pemrograman C++. Junlah Jurusan Teknik Elektro.
Universtas Sriwijaya. Palembang.
[4] Selection Sort
http://geeksforgeeks.org/ di akses pada tanggal 7 November
2017
[5] Shell Sort
http://geeksforgeeks.org/ di akses pada tanggal 7 November
2017
[6] Sorting Algorithm
[7] http://geeksforgeeks.org/ di akses pada tanggal 6 November
2017
[8] Wahyudi, Nur Eko. (2009). Algoritma Sederhana dalam
Memahami Proses Pengurutan Data. Jurnal Fakultas
Teknologi Informasi. Universitas Stikubank. Semarang