Modul 9
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
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 n0, sehingga
berlaku: |f(n)|<=K|g(n0)| untuk semua n0>=n.
Metode Sorting
Comparison Based Sorting
Address Calculation Sorting
Transposition Sorting
Insert&Keep Sorted
Priority Queue
Divide&Conquer
Diminishing
Increment
Bubble Sort
Tree Sort
Insertion Sort
Heap Sort
Selection Sort
Quick Sort
Merge Sort
Shell Sort
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;
//Struktur BinTree
typedef struct tNode* addressBT; //address utk BinTree disebut addressBT typedef struct tNode
{
infotype Info;
addressBT Left,Right; } Node;
typedef addressBT BinTree;
//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*/
//---// //primitif tree
void CreateEmptyTree(BinTree &BT); /*IS: BT sembarang belum terdefinisi FS terdefinisi kosong */
bool IsEmptyTree(BinTree BT); /*I: BT terdefinisi mungkin kosong
O: TRUE jika BT kosong, dan FALSE jika tidak */
bool IsLeaf(BinTree BT);
/*I: BT terdefinisi tidak kosong
O: TRUE jika BT cuma berupa daun, dan FALSE jika tidak */
addressBT Alokasi(infotype X); /*I: X terdefinisi
O: returnkan Node baru berinfo X, pointer Left & Right-nya NULL */
void InsVTree(BinTree &BT, infotype X, int &icounter); /*IS: BT terdefinisi BST, X terdefinisi
FS: BT ketambahan node baru berinfo X */
void InsArrayFromTree(Array &A, BinTree BT);
/* IS : BT terdefinisi mungkin kosong, A terdefinisi mungkin kosong PS : BT ditelusuri secara InOrder sambil infonya dimasukkan ke A FS : A bertambah berisi dengan nilai-nilai dari BT */
//metode sorting
void bubbleSort(Array &A);
/* IS: A terdefinisi tidak kosong, belum tentu urut PS: sort secara Bubble
FS: A tersortir Asc */
void insertionSort(Array &A);
/* IS: A terdefinisi tidak kosong, belum tentu urut PS: sort secara Insertion
FS: A tersortir Asc */
void treeSort(Array &A, BinTree BT);
/* IS: A terdefinisi tidak kosong, belum tentu urut PS: sort secara TreeSort
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 */
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
#include "xxxxsorting.h"
//primitif-primitif array void CreateEmpty(Array &A) {
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++;
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; }
//===============================================================// //primitif-primitif bin tree
void CreateEmptyTree(BinTree &BT) {
BT=NULL; }
bool IsEmptyTree(BinTree BT) {
return(BT==NULL); }
bool IsLeaf(BinTree BT) {
return(IsEmptyTree(BT->Left)&&IsEmptyTree(BT->Right)); }
addressBT Alokasi(infotype X) {
void InsVTree(BinTree &BT, infotype X, int &icounter)
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]) {
cout<<"\nCacah komparasi :"<<icounter<<endl; cout<<"Cacah swap :"<<cswap<<endl;
cout<<"Total :"<<icounter + cswap<<endl; }
void insertionSort(Array &A) {
int i,j,icounter,cswap; icounter =0;
cswap=0; infotype K; for(i=1;i<=A.Last;i++) {
K=A.T[i]; j=i-1;
A.T[-1]=K; while(K<A.T[j]) {
cout<<"\nCacah komparasi :"<<icounter<<endl; cout<<"Cacah swap :"<<cswap<<endl;
void InsArrayFromTree(Array &A, BinTree BT)
void treeSort(Array &A, BinTree BT) {
int i,icounter=0,cswap=0; CreateEmptyTree(BT); for(i=0;i<=A.Last;i++) {
InsVTree(BT,A.T[i],icounter); }
CreateEmpty(A);
InsArrayFromTree(A, BT); PrintInfo(A);
cout<<"\nCacah komparasi :"<<icounter<<endl; cout<<"Cacah swap :"<<cswap<<endl; }
// primitif-primitif merge sort Array Clone(Array A)
{
int i; Array temp;
for(i=0;i<=A.Last;i++) 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;
void Merge(Array &A, Array B, int &compare, int &cassign) {
Array temp;
CreateEmpty(temp); int i=0,j=0,k;
{
if(i>A.Last) //i habis duluan {
void MergeSort(Array &A, int &compare, int &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;
compare++;
void QuickSort(Array &A, int First, int Last, int &compare, int &cassign) {
int i=First;
if(First<Last)
File mxxxxsorting.cpp
#include"xxxxsorting.h"
int main() {
int n,pilih;
int compare,cswap; Array A;
BinTree BT;
CreateEmptyTree(BT); do
{
system("CLS");
cout<<"---MENU DEMO MODUL 8 ----"<<endl; cout<<"1. Set Array "<<endl;
cout<<"2. Print Array"<<endl; cout<<"3. Bubble Sort"<<endl; cout<<"4. Insertion Sort "<<endl; cout<<"5. Tree Sort "<<endl; cout<<"6. Merge Sort"<<endl; cout<<"7. 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:
cout<<"Sebelum Insertion Sort : "; PrintInfo(A);
cout<<"Setelah Insertion Sort : "; insertionSort(A);
getch(); break; case 5:
cout<<"Sebelum Tree Sort : "; PrintInfo(A);
cout<<"Setelah Tree Sort : "; treeSort(A,BT);
getch(); break; case 6:
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 7 :
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;
getch(); break; }
}while(pilih!=0); return 0;
