Modul
10
Sorting
dan
Analisis
Algoritma
A. TUJUAN
1. Memahami berbagai metode sorting
2. Melakukan analisis algoritma terhadap metode sorting tertentu
3. Mengetahui tingkat kompleksitas komputasi suatu algoritma
4. Memahami kegunaan analisis algoritma
B.
DASAR TEORI
1. Pengertian Sorting
Proses mengurutkan data secara ascending atau descending.
2. Asumsi Dasar
a.
Sorting dikenakan kepada kumpulan item atau objek yang mempunyai kunci
(misalnya array of integer atau list integer).
b.
Kunci-kunci itu harus dapat diperbandingkan satu sama lain.
c.
Pada array, kunci dapat berupa nilai elemen array itu sendiri dan pada list kunci
biasanya berupa info elemen list.
d.
Sorting dapat ascending atau descending.
3. Metode
3.1 Comparison Based Sorting
a. Transposition Sorting (pertukaran)
i. Bubble Sort
b. Insert and Keep Sorted (penyisipan)
i. Insertion Sort
ii. Tree Sort
c. Pririty Queue (antrian prioritas)
i. Selection Sort
ii. Heap Sort
d. Divide and Conquer (bagi dan urutkan)
i. Quick Sort
ii. Merge Sort
e. Diminishing Increment (penambahan mundur)
i. Shell Sort
3.2 Address Calculating Sorting
a. Proxmap Sort
Metode Sorting
Comparison Based Sorting
Address Calculation Sorting
Transposition Sorting
Proxmap Sort
Radix Sort
Bubble Sort
Insert&Keep Sorted
Diminishing
Increment
Insertion Sort Tree Sort
Shell Sort
Priority Queue
Divide&Conquer
Selection Sort
Heap Sort
Quick Sort
Merge Sort
4. Keperluan Analisis Algoritma
Bagaimana kita menilai karakteristik dan mengukur kinerja suatu algoritma
Jika algoritma itu dapat diekspresikan ke banyak bahasa pemrograman.
Dapat dijalankan di berbagai mesin dengan kecepatan yang bervariasi.
Dapat menjalankan data dengan kuantitas yang bervariasi.
Analisis algoritma diterapkan untuk mendapatkan “ekspresi yang representatif” untuk
algoritma yang sedang dianalisis. Ekspresi ini harus bebas bahasa, bebas mesin, dan
bebas data. Ekspresi ini diperlukan untuk menggambarkan kinerja suatu algoritma
dengan cepat dan tentu saja ekspresif.
5. Notasi Big O
a. Untuk mengkspresikan kompleksitas suatu algoritma.
b. Jika f(n)=an
2+bn+c maka f(n) dikatakan sebagai O(n
2).
c. Notasi Big O hanya akan mengambil suku dominannya saja, misalnya dalam f(n)
suku dominannya adalah an
2, karena suku-suku yang lain, bn+c, tidak terlalu
signifikan di dalam memperngaruhi f(n).
d. Big O juga menghilangkan konstanta yang melekat pada suku dominan, a, sehingga
Big O menjadi O(n
2) saja, karena yang diperntingkan adalah pengungkapan pola
umum kurva konsumsi sumber daya algoritma.
e. Big O efektif jika n cukup besar.
6. Definisi Formal Notasi O
a. Dikatakan f(n) adalah O(g(n)) jika ada dua konstanta positif K dan n
0, sehingga
b. Jika n merupakan parameter ukuran input untuk algoritma A, maka algoritma A
akan selesai dalam O(g(n))langkah.
c. Artinya banyaknya langkah sesungguhnya adalah tidak lebih dari suatu konstanta
dikalikan dengan g(n).
C.
DEMO
File xxxxsorting.h
//array versi 1
//Array selalu dimulai dari index 0,
// jika cuma ada satu elemen, pasti elemen indeks ke 0
//Ukuran Array ditentukan diluar ADT //Selalu kontigu, sesuai definisi array
#include <iostream.h> #include <stdlib.h> #include <conio.h>
//Struktur Array
const MaxEl=100;
typedef int infotype;
typedef int address; //ingat lho address di sini adalah int
typedef struct {
infotype T[MaxEl]; // nilai elemen dalam array address First; // indeks penunjuk elemen awal address Last; // indeks penunjuk elemen akhir } Array;
//primitif array
void CreateEmpty(Array &A); /*IS: A belum terdefinisi
FS: A terdefinisi kosong */
bool IsEmpty(Array A);
/*I: A terdefinisi mungkin kosong
O: TRUE jika A kosong dan FALSE jika tidak */
bool IsOneElmt(Array A);
/*I: A terdefinisi mungkin kosong
O: TRUE jika A terdiri dari 1 elemen dan FALSE jika tidak */
void Add(Array &A, infotype x);
infotype getElmtAt(Array A,int i); /*I: A, i terdefinisi
O: mereturnkan elemen ke-i dari array A */
void setArray(Array &A, int n);
/*I : A terdefinisi kosong, n terdefinisi
FS: A berisi sebanyak n elemen, nilai dari user lewat cin (tdk recommended) */
void swap(int &a, int &b); /*I: a dan b terdefinisi
FS: nilai a dan b ditukar*/
//---// //metode sorting
void bubbleSort(Array &A);
/* IS: A terdefinisi tidak kosong, belum tentu urut PS: sort secara Bubble
FS: A tersortir Asc */
void Arrange(Array &A, int First, int Last, int &count, int &sw); /* IS: A terdefinisi tidak kosong, belum tentu urut
PS: sort secara Bubble FS: A tersortir Asc */
void QuickSort(Array &A, int First, int Last, int &icounter,int &cassign); /* IS: semua parameter terdefinisi
FS: A tersirtir secara QuickSort */
Array Clone(Array A); /* I: A terdefinisi
O: mereturnkan Array baru yang isinya sama persis dengan A */
void Cloning(Array &Aout, Array &Ain); /* IS: Ain terdefinisi, Aout sebarang
FS: Aout berisi elemen2 seperti pada Ain, Ain tetap */
void BreakIntoTwo(Array &A, Array &A2); /* IS: A terdefinisi, A2 sebarang
FS: A tinggal separo sebelah kiri, A2 berisi separo sebelah kanan dari A */
void PrintInfo(Array A); /* IS: A terdefinisi
FS: mencetak semua elemen A ke layar */
void Merge(Array &A, Array t,int &compare, int &cassign); /* IS: semua paramater terdefinisi
FS: A ketambahan elemen2 dari t secara sorted, t tetap */
void MergeSort(Array &A,int &compare, int &cassign); /*IS: semua parameter terdefinisi
FS: A tersortir */
****************************************************************
File xxxxsorting.cpp
A.First=-1; A.Last=-1; }
bool IsEmpty(Array A) {
return(A.First==-1&&A.Last==-1); }
bool IsOneElmt(Array A) {
return(A.First==0&&A.Last==0); }
void Add(Array &A, infotype x) {
A.T[A.Last+1]=x; A.Last++;
//atau bisa juga A.T[++A.Last]=x;
}
infotype getElmtAt(Array A,int i) {
return(A.T[i]); }
int Length(Array A) {
return(A.Last+1); }
void swap(int &a, int &b) {
int temp=a; a=b;
b=temp; }
void PrintInfo(Array A) {
int i;
for(i=0;i<=A.Last;i++) {
cout<<A.T[i]<<" "; }
cout<<endl; }
void setArray(Array &A, int n) {
int i;
CreateEmpty(A); for(i=0;i<n;i++) {
cout<<"Masukkan data ke "<<i+1<<" : "; cin>>A.T[i];
}
A.Last=n-1; }
void bubbleSort(Array &A) {
int i,j,icounter,cswap; icounter =0; cswap=0; for(i=0;i<=A.Last-1;i++) {
for(j=i+1;j<=A.Last;j++) {
if(A.T[i]>A.T[j]) {
swap(A.T[i],A.T[j]); cswap++;
}
icounter++; }
}
PrintInfo(A);
cout<<"\nCacah komparasi :"<<icounter<<endl; cout<<"Cacah swap :"<<cswap<<endl;
cout<<"Total :"<<icounter + cswap<<endl; }
// primitif-primitif merge sort Array Clone(Array A)
{
int i; Array temp;
for(i=0;i<=A.Last;i++) {
temp.T[i]=A.T[i]; }
temp.First=A.First; temp.Last=A.Last; return temp; }
void Cloning(Array &Aout, Array Ain) {
Aout=Clone(Ain); }
void BreakIntoTwo(Array &A, Array &A2) {
int i,len=Length(A); A.First=0;
A.Last=len/2+len%2-1; A2.First=0;
A2.Last=len-Length(A)-1; for(i=0;i<=A2.Last;i++) {
A2.T[i]=A.T[i+Length(A)]; }
}
void Merge(Array &A, Array B, int &compare, int &cassign) {
Array temp;
{
compare++;
if(A.T[i]<B.T[j]) {
} else {
} }
Add(temp,A.T[i]); cassign++;
i++;
Add(temp,B.T[j]); cassign++;
j++;
compare++;
if(i>A.Last) //i habis duluan {
for(k=j;k<=B.Last;k++) {
cassign++;
Add(temp,B.T[k]); }
}
else // j habis duluan {
for(k=i;k<=A.Last;k++) {
cassign++;
Add(temp,A.T[k]); }
}
A=Clone(temp); }
void MergeSort(Array &A, int &compare, int &cassign) {
Array B;
if(Length(A)>1) {
BreakIntoTwo(A,B);
MergeSort(A,compare,cassign); MergeSort(B,compare,cassign); Merge(A,B,compare,cassign); }
}
//primitif-primitif quick sort
void Arrange(Array &A, int First, int Last, int &cswap, int &compare) {
int i=First+1,j=Last;
while(A.T[i]<A.T[First]) {
i++;
compare++; }
while(A.T[j]>A.T[First]) {
compare++; }
while(i<j) {
swap(A.T[i],A.T[j]); cswap++;
while(A.T[i]<A.T[First]) {
i++;
compare++; }
while(A.T[j]>A.T[First]) {
j--;
compare++; }
}
if(A.T[i]==A.T[First]) {
i++;
compare++; }
swap(A.T[First],A.T[j]); cswap++;
}
void QuickSort(Array &A, int First, int Last, int &compare, int &cassign) {
int i=First;
if(First<Last) {
Arrange(A,First,Last,compare,cassign); QuickSort(A,First,(i-1),compare,cassign); QuickSort(A,(i+1),Last,compare,cassign); }
}
//---//
File mxxxxsorting.cpp
#include"xxxxsorting.h"
int main() {
int n,pilih;
int compare,cswap; Array A;
do {
system("CLS");
cout<<"---MENU DEMO MODUL 10 ----"<<endl; cout<<"1. Set Array "<<endl;
cout<<"2. Print Array"<<endl; cout<<"3. Bubble Sort"<<endl; cout<<"4. Merge Sort"<<endl; cout<<"5. Quick Sort "<<endl; cout<<"0. keluar "<<endl;
cin>>pilih; switch(pilih) {
case 0: cout<<"Keluar "<<endl; break;
case 1:
cout<<"Masukkan jumlah elemen dalam array : ";cin>>n; setArray(A,n);
cout<<"Array telah terbentuk "<<endl; PrintInfo(A);
cout<<endl; getch(); break; case 2:
cout<<"Tampil Array "<<endl; PrintInfo(A);cout<<endl; getch();
break; case 3:
cout<<"Sebelum Bubble Sort : "; PrintInfo(A);
cout<<"Setelah Bubble Sort : "; bubbleSort(A);
getch(); break; case 4:
compare=0,cswap=0;
cout<<"Sebelum Merge Sort : "; PrintInfo(A);
MergeSort(A,compare,cswap);
cout<<"Setelah Merge Sort : ";PrintInfo(A); cout<<"\nCacah komparasi : "<<compare<<endl; cout<<"Cacah Asignment : "<<cswap<<endl;
cout<<"Total : "<<compare+cswap<<endl; getch();
break;
case 5 : compare=0,cswap=0;
cout<<"Sebelum Quick Sort : "; PrintInfo(A);
QuickSort(A,0,A.Last,compare,cswap);
cout<<"Setelah Quick Sort : ";PrintInfo(A); cout<<"\nCacah komparasi : "<<compare<<endl; cout<<"Cacah Asignment/swap : "<<cswap<<endl; cout<<"Total : "<<compare+cswap<<endl; getch();
break;
default:cout<<"Masukkan pilihan menu 0-5"<<endl; getch();
break; }
}while(pilih!=0); return 0;
