Metode Algoritma Pengurutan (sort)
1.
Heap Sort
Heapsort
merupakan salah satu bentuk dari selection sort yang memiliki kompleksitas
algorima O(n log(n)) yang menggunakan struktur data heap. Algoritma ini bekerja
dengan menentukan elemen terbesar (atau terkecil) dari sebuah daftar elemen,
dan diletakkan pada akhir (atau awal) dari daftar tersebut. Heap sort
menyelesaikan sebuah pengurutan menggunakan struktur data yang disebut heap.
Heap merupakan sebuah pohon biner hampir lengkap dimana isi dari simpul ayah
selalu lebih besar dari isi simpul anak-anaknya sehingga simpul akar selalu
merupakan elemen terbesar.
Metode Heap Sort
:
·
Metode UpHeap
o bandingkan kunci terakhir dengan parentnya apabila
parent < kunci maka lakukan pertukaran.
o ulangi langkah g g 1 dengan membandingkan dengan
parent selanjutnya sampai posisi parent di level 1 selesai dibandingkan
·
Metode DownHeap
o Bandingkan parent dengan leftchild dan rightchild
apabila parent < leftchild atau rightchild maka lakukan pertukaran.
o Ulangi langkah 1 dengan membandingkan dengan
leftchild dan rightchild pada posisi level dibawahnya sampai posisi di level
terakhir selesai dibandingkan.
Prosedur :
function
heapSort(a, count) is
input: sebuah
larik tidak terurut a dengan panjang length
(pertama letakkan
a dalam max-heap) heapify(a, count)
end := count -1
while end > 0
do
remove ( )
reheapify ( )
end := end – 1
2.
Shell sort
Pengertian :
Metode ini
disebut juga dengan metode pertambahan menurun (diminishing increment). Metode
ini dikembangkan oleh Donald L. Shell pada tahun 1959, sehingga sering disebut
dengan Metode Shell Sort. Metode ini mengurutkan data dengan cara membandingkan
suatu data dengan data lain yang memiliki jarak tertentu, kemudian dilakukan
penukaran bila diperlukan. Proses pengurutan dengan metode Shell dapat
dijelaskan sebagai berikut :
Pertama-tama
adalah menentukan jarak mula-mula dari data yang akan dibandingkan, yaitu N /
2. Data pertama dibandingkan dengan data dengan jarak N / 2. Apabila data
pertama lebih besar dari data ke N / 2 tersebut maka kedua data tersebut
ditukar. Kemudian data kedua dibandingkan dengan jarak yang sama yaitu N / 2.
Demikian seterusnya sampai seluruh data dibandingkan sehingga semua data ke-j
selalu lebih kecil daripada data ke-(j + N / 2).
Pada proses berikutnya, digunakan jarak (N / 2) / 2 atau N / 4. Data pertama
dibandingkan dengan data dengan jarak N / 4. Apabila data pertama lebih besar
dari data ke N / 4 tersebut maka kedua data tersebut ditukar. Kemudian data
kedua dibandingkan dengan jarak yang sama yaitu N / 4. Demikianlah seterusnya
hingga seluruh data dibandingkan sehingga semua data ke-j lebih kecil daripada
data ke-(j + N / 4).
Pada proses berikutnya, digunakan jarak (N / 4) / 2 atau N / 8. Demikian
seterusnya sampai jarak yang digunakan adalah 1.
Algoritma metode Shell dapat dituliskan sebagai berikut :
1. Jarak = N
2. Selama (Jarak > 1) kerjakan baris 3 sampai dengan 9
3. Jarak = Jarak / 2. Sudah = false
4. Kerjakan baris 4 sampai dengan 8 selama Sudah = false
5. Sudah = true
6. j = 0
7. Selama (j < N – Jarak) kerjakan baris 8 dan 9
8. Jika (Data[j] > Data[j + Jarak] maka tukar Data[j],
Data[j + Jarak].
Sudah = true
9. j = j + 1
Di bawah ini merupakan prosedur yang menggunakan metode Shell:
void ShellSort(int N)
{
int Jarak, i, j;
bool Sudah;
Jarak = N;
while(Lompat > 1)
{
Jarak = Jarak / 2;
Sudah = false;
while(!Sudah)
{
Sudah = true;
for(j=0; j<N-Jarak; j++)
{
i = j + Jarak;
if(Data[j] > Data[i])
{
Tukar(&Data[j], &Data[i]);
Sudah = false;
} } } } }
Metode Shell Sort :
3.
Quick Sort
Pengertian :
Metode
Quick sering disebut juga metode partisi (partition exchange sort). Metode ini
diperkenalkan pertama kali oleh C.A.R. Hoare pada tahun 1962. Untuk
mempertinggi efektifitas dari metode ini, digunakan teknik menukarkan dua
elemen dengan jarak yang cukup besar. Proses penukaran dengan metode quick
dapat dijelaskan sebagai berikut:
Mula-mula dipilih data tertentu yang disebut pivot, misalnya x. Pivot dipilih
untuk mengatur data di sebelah kiri agar lebih kecil daripada pivot dan data di
sebelah kanan agar lebih besar daripada pivot. Pivot ini diletakkan pada posisi
ke j sedemikian sehingga data antara 1 sampai dengan j-1 lebih kecil daripada
x. Sedangkan data pada posisi ke j+1 sampai N lebih besar daripada x. Caranya
dengan menukarkan data diantara posisi 1 sampai dengan j-1 yang lebih besar
daripada x dengan data diantara posisi j+1 sampai dengan N yang lebih kecil
daripada x.
---( Metode Quick Sort Non Rekursif
Implementasi secara non rekursif memerlukan dua buah tumpukan (stack) yang
digunakan yang digunakan untuk menyimpan batas-batas subbagian. Pada prosedur
ini menggunakan tumpukan yang bertipe record (struktur) yang terdiri dari
elemen kiri (untuk mencatat batas kiri) dan kanan (untukmencatat batas kanan.
Tumpukan dalam hal ini dideklarasikan sebagai array.
Algoritma quick sort non rekursif dapat dituliskan sebagai berikut :
1. Tumpukan[1].Kiri = 0
2. Tumpukan[1].Kanan = N-1
3. Selama ujung ≠ 0 kerjakan baris 4 sampai dengan 22
4. L = Tumpukan[ujung].Kiri
5. R = Tumpukan[ujung].Kanan
6. ujung = ujung – 1
7. Selama (R > L) kerjakan baris sampai 8 dengan 22
8. i = L
9. j = R
10. x = Data[(L + R) / 2]
11. Selama i <= j kerjakan baris 12 sampai dengan 14
12. Selama (Data[i] < x), i = i + 1
13. Selama (x < Data[j]), j = j – 1
14. Jika (i <= j) maka kerjakan baris 15 sampai dengan 17, jika tidak ke
baris 11
15. Tukar Data[i] dengan Data[j]
16. i = i + 1
17. j = j –1
18. Jika (L < i) maka kerjakan baris 19 sampai dengan 21
19. ujung = ujung + 1
20. Tumpukan[ujung].Kiri = I
21. Tumpukan[ujung].Kanan = R
22. R = j
Di bawah ini merupakan prosedur yang menggunakan metode quick dengan non
rekursi:
void QuickSortNonRekursif(int N)
{
const M = MaxStack;
struct tump
{
int Kiri;
int Kanan;
}
Tumpukan[M];
int i, j, L, R, x, ujung = 1;
Tumpukan[1].Kiri = 0;
Tumpukan[1].Kanan = N-1;
while (ujung!=0)
{
L = Tumpukan[ujung].Kiri;
R = Tumpukan[ujung].Kanan;
ujung--;
while(R > L)
{
i = L;
j = R;
x = Data[(L+R)/2];
while(i <= j)
{
while(Data[i] < x)
i++;
while(x < Data[j])
j--;
if(i <= j)
{
Tukar(&Data[i], &Data[j]);
i++;
j--;
}
}
if(L < i)
{
ujung++;
Tumpukan[ujung].Kiri = i;
Tumpukan[ujung].Kanan = R;
}
R = j;
}
}
}
---( Metode Quick Sort Rekursif
Algoritma quick Rekursif dapat dituliskan sebagai berikut :
1. x = Data[(L + R) / 2]
2. i = L
3. j = R
4. Selama ( i <= j) kerjakan baris 5 sampai dengan 12
5. Selama (Data[i] < x) kerjakan i = i + 1
6. Selama (Data[j] > x) kerjakan j = j – 1
7. Jika (i <= j) maka kerjakan baris 8 sampai 10; jika tidak kerjakan baris
11
8. Tukar Data[i] dengan Data[j]
9. i = i + 1
10. j = j –1
11. Jika (L < j) kerjakan lagi baris 1 dengan R = j
12. Jika (i < R) kerjakan lagi baris 1 dengan L = i
Dibawah ini merupakan prosedur yang menggunakan metode quick dengan rekursi:
void QuickSortRekursif(int L, int R)
{
int i, j, x;
x = data[(L+R)/2];
i = L;
j = R;
while (i <= j)
{
while(Data[i] < x)
i++;
while(Data[j] > x)
j--;
if(i <= j)
{
Tukar(&Data[i], &Data[j]);
i++;
j--;
}
}
if(L < j)
QuickSortRekursif(L, j);
if(i < R)
QuickSortRekursif(i, R);
}
4.
Merge Sort
Pengertian :
Merge sort
merupakan salah satu teknik sorting yang menurutkan suatu data dengan cara
penggabungan. Merge sort juga menggunakan proses divide and conquer pada
rekursi. Berikut adalah langkah kerja merge sort :
Devide
: Memilah elemen – elemen dari data menjadi dua bagian.
Conquer
: Menyelesaikan setiap bagian dengan memanggil prosedur merge sort secara
rekursif.
Kombinasi :
Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan
rangkaian data berurutan.
Proses rekursi
akan berhenti jika telah mencapai lemen dasar, atau artinya jika bagian yang
diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu elemen tersebut
menandakan bahwa bagian tersebut telah sesuai rangkaian.
Metode penggabungan biasanya digunakan pada pengurutan
berkas. Prinsip dari metode penggabungan sebagai berikut :
Mula-mula diberikan dua kumpulan data yang sudah dalam keadaan urut. Kedua
kumpulan data tersebut harus dijadikan satu table sehingga dalam keadaan urut.
Misalnya kumpulan data pertama (T1) adalah sebagai berikut :
3 11 12 23 31
Sedangkan kumpulan data kedua (T2) adalah sebagai berikut :
9 15 17 20 35
Proses penggabungan ini dapat
dijelaskan sebagai berikut : mula-mula diambil data pertama dari T1 yaitu 3 dan
data pertama dari T2 yaitu 9. Data ini dibandingkan, kemudian yang lebih kecil
diletakkan sebagai data pertama dari hasil pengurutan, misalnya T3. Jadi T3
akan memiliki satu data yaitu 3. Data yang lebih besar yaitu 9 kemudian
dibandingkan dengan data kedua dari T1, yaitu 11. Ternyata 9 lebih kecil dari
11, sehingga 9 diletakkan sebagai data kedua dari T3. Demikian seterusnya
sehingga didapat hasil sebagai berikut :
3 9 11 12 15 17 20 23 31 35
Algoritma penggabungan dapat dituliskan sebagai berikut :
1. i = 0
2. j = 0
3. J3 = 0
4. Kerjakan baris 5 sampai dengan 7 selama (i < J1) atau (j < J2)
5. J3 = J3 + 1
6. Jika (T1[i] < T2[j]) maka T3[J3] = T1[i], i = i + 1
7. Jika (T1[i] >= T2[j]) maka T3[J3] = T2[j], j = j + 1
8. Jika (i > J1) maka kerjakan baris 9, jika tidak kerjakan baris 15
9. i = j
10. Selama (i < J2) kerjakan baris 11 sampai dengan 13
11. J3 = J3 + 1
12. T3[J3] = T2[i]
13. i = i + 1
14. Selesai
15. j = i
16. Selama (j < J1) kerjakan baris 17 sampai dengan 19
17. J3 = J3 + 1
18. T3[J3] = T1[j]
19. j = j + 1
Di bawah ini merupakan prosedur penggabungan dua kumpulan data yang sudah dalam
keadaan urut:
void MergeSort(int T1[],int T2[],int J1,int J2, int T3[],int *J3)
{
int i=0, j=0;
int t=0;
while ((i<J1)||(j<J2))
{
if(T1[i]<T2[j])
{
T3[t] = T1[i];
i++;
}
else
{
T3[t] = T2[j];
j++;
}t++;
}
if(i>J1)
for(i=j; i<J2; i++)
{
T3[t] = T2[i];
t++;
}
if(j>J2)
for(j=i; j<J1; j++)
{
T3[t] = T1[j];
t++;
}
*J3 = t;
}
5.
Radix Sort
Pengertian :
Radix sort adalah
salah satu algoritma sorting yang dilakukan tanpa melakukan perbandingan
antardata yang dijadikan sebagai input. Makna harfiah Radix dapat diartikan
sebagai posisi dalam angka. Dalam system decimal, radix adalah digit dalam
angka decimal. Misalkan angka 37 mempunyai nilai radix 3 dan 7. Berdasarkan
urutan pemrosesan radix-nya, ada 2 macam Radix sort. Pertama adalah LSD (Least
Significant Digit) yaitu proses dimulai dari radix yang paling tidak
signifikan(digit yang paling kanan). Kedua adalah MSD (Most Significant Digit),
yaitu proses dimulai dari radix yang paling signifikan (digit yang paling
kiri).
Radix Sort merupakan salah satu algoritma Non-Comparasion Sort
(pengurutan tanpa pembandingan). Proses yang dilakukan dalam metode ini adalah
mengklasifikasikan data sesuai dengan kategori terurut yang tertentu, dan tiap
kategori dilakukan pengklasifikasian lagi, dan seterusnya sesuai kebutuhan,
lalu subkategori-kategori tersebut digabungkan kembali.
Secara harfiah Radix dapat diartikan sebagai posisi dalam angka,
karena metode ini pertamakalinya mengurutkan nilai-nilai input berdasarkan
radix pertamanya, lalu pengurutan dilakukan berdasarkan radix keduanya, dan
begitu seterusnya. Pada system desimal, radix adalah digit dalam angka desimal.
Dalam system bilangan desimal, digit – digit suatu bilangan dapat dikelompokkan
menjadi 10 kelompok, yaitu kelompok “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”,
“8”, “9”, dengan demikian harga suatu bilangan dapat diidentifikasikan ke dalam
kelompok – kelompok digit tersebut.
Ide
dasar dari metode Radix sort ini adalah mengkategorikan data – data menjadi
subkumpulan data sesuai dengan nilai radixnya kemudian mengkategorikannya
kembali berdasar nilai radix lainnya.
