SORTING : SELECTION, INSERTION, DAN
BUBBLE SORT
SORTING
Sorting (Pengurutan Data) dapat didefinisikan sebagai suatu proses untuk
menyusun kembali humpunan obyek menggunakan aturan tertentu. Tujuan dari sorting
yaitu memudahkan dalam pencarian anggota dari suatu himpunan.
Ada banyak jenis metode sorting, yaitu ada :
1)
Selection Sort;
2)
Insertion Sort;
3)
Bubble Sort;
4)
Radix Sort;
5)
Merge Sort;
6)
Shell Sort;
7)
Quick Sort; dll.
Disini saya akan membahas 3 metode sorting saja yaitu selection,
insertion, dan bubble sort.
Dalam metode sorting, ada 2 macam pengurutan, yaitu pengurutan data dari
kecil ke besar (Ascending), dan pengurutan data dari yang terbesar ke terkecil
(Descending).
SELECTION SORT
Metode
seleksi adalah pengurutan data dengan cara mencari data yang terkecil kemudian
menukarnya dengan data yang digunakan sebagai acuan (pivot).
Proses
dari Selection Sort Ascending adalah sebagai berikut :
1.
Mencari data
terkecil dari data pertama sampai dengan data yang terakhir. Kemudian posisinya
ditukar dengan data yang pertama.
2.
Mencari data
terkecil dari data kedua sampai dengan data terakhir, kemudian posisinya
ditukar dengan data yang kedua.
3.
Mencari data
terkecil dari data ketiga sampai dengan data terakhir, kemudian posisinya
ditukar dengan data yang ketiga.
4.
Begitu seterusnya
sampai semua data terurut naik. Apabila terdapat n buah data yang akan
diurutkan, maka membutuhkan (n-1) langkah pengurutan, dengan data terakhir,
yaitu data ke n tidak perlu diurutkan karena hanya tinggal data satu-satunya.
Untuk
proses dari Selection Sort Descending (mencari data terbesar) adalah kebalikan
dari proses di atas.
Sebagai
contoh :
Terdapat
suatu variable array dimana nilai dalam array tersebut :
NILAI[8]
= { 44, 55, 12, 42, 94, 18, 6, 67 }
Penyelesaiannya
adalah :
Agar
lebih jelasnya kita langsung saja ke studi kasusnya dan source codenya pada
borland C++ :
Selection Sort Ascending
Inputkan
banyaknya data yang akan dilakukan sorting (max. 10). Inputkan data sesuai
dengan banyaknya data yang diminta, kemudian urutkanlah data tersebut dari yang
terkecil ke yang terbesar!
Source
code :
#include<iostream.h>
#include<conio.h>
int data[10];
int n;
void tukar(int a, int b)
{
int t;
t=data[b];
data[b]=data[a];
data[a]=t;
}
void main()
{
int pos,i,j;
cout<<"-------------------------------------------------"<<endl;
cout<<"SELECTION
SORT ASCENDING"<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"INPUTKAN
BANYAK DATA = ";
cin>>n;
cout<<"-------------------------------------------------"<<endl;
for(int
i=0;i<n;i++)
{
cout<<"INPUTKAN
DATA KE-"<<(i+1)<<" = " ;
cin>>data[i];
}
cout<<"-------------------------------------------------"<<endl;
cout<<"DATA
YANG DIINPUTKAN :"<<endl;
for(i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"-------------------------------------------------"<<endl;
for(i=0;i<n-1;i++)
{
pos=i;
for(j=i+1;j<n;j++)
{
if(data[j]<data[pos])pos=j;
}
if(pos!=i)
tukar(pos,i);
}
cout<<"DATA
YANG TELAH DIURUTKAN SECARA ASCENDING : "<<endl;
for(int
i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"SELECTION
SORT SELESAI !"<<endl;
cout<<"-------------------------------------------------"<<endl;
getch();
}
Berikut
ini hasil dari source code di atas :
Selection Sort Descending
Buatlah
program seperti diatas, tetapi urutkan data dari yang terbesar ke terkecil.
Source
code :
#include<iostream.h>
#include<conio.h>
int data[10];
int n;
void tukar(int a, int b)
{
int t;
t=data[b];
data[b]=data[a];
data[a]=t;
}
void main()
{
int pos,i,j;
cout<<"-------------------------------------------------"<<endl;
cout<<"SELECTION
SORT DESCENDING"<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"INPUTKAN
BANYAK DATA = ";
cin>>n;
cout<<"-------------------------------------------------"<<endl;
for(int
i=0;i<n;i++)
{
cout<<"INPUTKAN
DATA KE-"<<(i+1)<<" = " ;
cin>>data[i];
}
cout<<"-------------------------------------------------"<<endl;
cout<<"DATA
YANG DIINPUTKAN :"<<endl;
for(i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"-------------------------------------------------"<<endl;
for(i=0;i<n-1;i++)
{
pos=i;
for(j=i+1;j<n;j++)
{
if(data[j]>data[pos])pos=j;
}
if(pos!=i)
tukar(pos,i);
}
cout<<"DATA
YANG TELAH DIURUTKAN SECARA DESCENDING : "<<endl;
for(int
i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"SELECTION
SORT SELESAI !"<<endl;
cout<<"-------------------------------------------------"<<endl;
getch();
}
Hasilnya
jika telah di run adalah :
INSERTION SORT
Pada
metode insertion sort, proses pengurutannya dimulai dari data ke-2 (indeks
ke-1), kemudian disisipkan pada tempat yang sesuai. Dan data pertama (data pada
indeks ke-0) dianggap sudah pada tempatnya.
Kita
coba saja langsung ke studi kasus dan source codenya :
Insertion Sort Ascending
Studi
Kasus :
Buatlah
program seperti selection di atas, dan urutkan data tersebut dari terkecil ke
terbesar dengan menggunakan metode insertion sort.
Source
code :
#include<iostream.h>
#include<conio.h>
int data[10];
int n;
void main()
{
int tmp,i,j;
cout<<"-------------------------------------------------"<<endl;
cout<<"INSERTION
SORT ASCENDING"<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"INPUTKAN
BANYAKNYA DATA = ";
cin>>n;
cout<<"-------------------------------------------------"<<endl;
for(int
i=0;i<n;i++)
{
cout<<"INPUTKAN
DATA KE-"<<(i+1)<<" = " ;
cin>>data[i];
}
cout<<"-------------------------------------------------"<<endl;
cout<<"DATA
YANG DIINPUTKAN :"<<endl;
for(i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"-------------------------------------------------"<<endl;
for(i=1;i<n;i++)
{
tmp=data[i];
j=i-1;
while(data[j]>tmp
&& j>=0)
{
data[j+1]=data[j];
j--;
}
data[j+1]=tmp;
}
cout<<"DATA
YANG TELAH DIURUTKAN SECARA ASCENDING : "<<endl;
for(int
i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"INSERTION
SORT SELESAI !"<<endl;
cout<<"-------------------------------------------------"<<endl;
getch();
}
Berikut
adalah hasilnya jika di run :
Insertion Sort Descending
Studi
kasus :
Buatlah
program yang sama, tetapi urutkan dari yang terbesar ke terkecil.
Source
code :
#include<iostream.h>
#include<conio.h>
int data[10];
int n;
void main()
{
int tmp,i,j;
cout<<"-------------------------------------------------"<<endl;
cout<<"INSERTION
SORT DESCENDING"<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"INPUTKAN
BANYAKNYA DATA = ";
cin>>n;
cout<<"-------------------------------------------------"<<endl;
for(int
i=0;i<n;i++)
{
cout<<"INPUTKAN
DATA KE-"<<(i+1)<<" = " ;
cin>>data[i];
}
cout<<"-------------------------------------------------"<<endl;
cout<<"DATA
YANG DIINPUTKAN :"<<endl;
for(i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"-------------------------------------------------"<<endl;
for(i=1;i<n;i++)
{
tmp=data[i];
j=i-1;
while(data[j]<tmp
&& j>=0)
{
data[j+1]=data[j];
j--;
}
data[j+1]=tmp;
}
cout<<"DATA
YANG TELAH DIURUTKAN SECARA DESCENDING : "<<endl;
for(int
i=0;i<n;i++)
{
cout<<data[i]<<"
";
}
cout<<endl;
cout<<"-------------------------------------------------"<<endl;
cout<<"INSERTION
SORT SELESAI !"<<endl;
cout<<"-------------------------------------------------"<<endl;
getch();
}
Berikut
hasilnya jika di run :
BUBBLE SORT :
Dalam
bubble sort, prosesnya adalah selalu membandingkan 2 data yang berdekatan atau
disebelahnya.
Lebih
jelasnya langsung saja ke studi kasus dan source codenya.
Bubble Sort Ascending
Studi
Kasus :
Buatlah
program seperti selection dan insertion sort di atas dengan menggunakan metode
bubble sort, dan urutkan data tersebut dari yang terkecil ke terbesar.
Source
code :
#include<iostream.h>
#include<conio.h>
int data[20];
int n;
void main()
{
int i, j,
tmp;
cout<<"---------------------------------------------"<<endl;
cout<<"BUBBLE
SORT ASCENDING"<<endl;
cout<<"---------------------------------------------"<<endl;
cout<<"INPUTKAN
BANYAKNYA DATA : ";
cin>>n;
cout<<"---------------------------------------------"<<endl;
for(i=0;
i<n; i++)
{
cout<<"INPUTKAN
BILANGAN KE-["<<(i+1)<<"] : ";
cin>>data[i];
}
cout<<"---------------------------------------------"<<endl;
cout<<"DATA
YANG DIINPUTKAN : "<<endl;
for(i=0;
i<n; i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"---------------------------------------------"<<endl;
for(i=0;
i<n; i++)
{
for(j=i+1;
j<n; j++)
{
if(data[i]>data[j])
{
tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
}
cout<<"DATA
SETELAH DIURUTKAN SECARA ASCENDING : "<<endl;
for(i=0;
i<n; i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"---------------------------------------------"<<endl;
cout<<"BUBBLE
SORT SELESAI !"<<endl;
cout<<"---------------------------------------------"<<endl;
getch();
}
Berikut
hasilnya jika di run :
Bubble Sort Descending
Studi
kasus :
Buatlah
program seperti di atas, kemudian urutkan data dari terbesar ke terkecil.
Source
code :
#include<iostream.h>
#include<conio.h>
int data[20];
int n;
void main()
{
int i, j,
tmp;
cout<<"---------------------------------------------"<<endl;
cout<<"BUBBLE
SORT DESCENDING"<<endl;
cout<<"---------------------------------------------"<<endl;
cout<<"INPUTKAN
BANYAKNYA DATA : ";
cin>>n;
cout<<"---------------------------------------------"<<endl;
for(i=0;
i<n; i++)
{
cout<<"INPUTKAN
BILANGAN KE-["<<(i+1)<<"] : ";
cin>>data[i];
}
cout<<"---------------------------------------------"<<endl;
cout<<"DATA
YANG DIINPUTKAN : "<<endl;
for(i=0;
i<n; i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"---------------------------------------------"<<endl;
for(i=0;
i<n; i++)
{
for(j=i+1;
j<n; j++)
{
if(data[i]<data[j])
{
tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
}
cout<<"DATA
SETELAH DIURUTKAN SECARA DESCENDING : "<<endl;
for(i=0;
i<n; i++)
{
cout<<data[i]<<"
";
}
cout<<endl<<"---------------------------------------------"<<endl;
cout<<"BUBBLE
SORT SELESAI !"<<endl;
cout<<"---------------------------------------------"<<endl;
getch();
}
Dan
berikut hasil dari source code di atas jika di run :
SEKIAN MATERI SORTING DARI SAYA JIKA ADA KEKURANGAN
SAYA MOHON MAAF
TERIMA KASIH
Postingan
sangat membantu, terima kasih !!
BalasHapus