Struktur Data Modul 10 Sorting
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
b. Radix Sort
Praktikum Struktur Data - Sorting dan Analisis Algoritma
1
Metode Sorting
Comparison Based Sorting
Address Calculation Sorting
Proxmap Sort
Transposition Sorting
Radix Sort
Bubble Sort
Diminishing
Increment
Insert&Keep Sorted
Insertion Sort
Tree Sort
Shell Sort
Priority Queue
Selection Sort
Heap Sort
Divide&Conquer
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)=an2+bn+c maka f(n) dikatakan sebagai O(n2).
c. Notasi Big O hanya akan mengambil suku dominannya saja, misalnya dalam f(n)
suku dominannya adalah an2, 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(n2) 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)|=n.
Praktikum Struktur Data - Sorting dan Analisis Algoritma
2
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
#include
#include
//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);
/*I: A terdefinisi mungkin kosong, x terdefinisi
FS: Array A ketambahan elemen baru dengan nilai x*/
Praktikum Struktur Data - Sorting dan Analisis Algoritma
3
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
#include "xxxxsorting.h"
//primitif-primitif array
void CreateEmpty(Array &A)
{
Praktikum Struktur Data - Sorting dan Analisis Algoritma
4
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
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
b. Radix Sort
Praktikum Struktur Data - Sorting dan Analisis Algoritma
1
Metode Sorting
Comparison Based Sorting
Address Calculation Sorting
Proxmap Sort
Transposition Sorting
Radix Sort
Bubble Sort
Diminishing
Increment
Insert&Keep Sorted
Insertion Sort
Tree Sort
Shell Sort
Priority Queue
Selection Sort
Heap Sort
Divide&Conquer
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)=an2+bn+c maka f(n) dikatakan sebagai O(n2).
c. Notasi Big O hanya akan mengambil suku dominannya saja, misalnya dalam f(n)
suku dominannya adalah an2, 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(n2) 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)|=n.
Praktikum Struktur Data - Sorting dan Analisis Algoritma
2
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
#include
#include
//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);
/*I: A terdefinisi mungkin kosong, x terdefinisi
FS: Array A ketambahan elemen baru dengan nilai x*/
Praktikum Struktur Data - Sorting dan Analisis Algoritma
3
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
#include "xxxxsorting.h"
//primitif-primitif array
void CreateEmpty(Array &A)
{
Praktikum Struktur Data - Sorting dan Analisis Algoritma
4
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