[221].STRUKTUR DATA: Sorting Method
---------------------------------------------------------
Author : y3ppy
Contact : y3ppy_neutron@yahoo.com
CopyLEFT (c) 2007
www.spyrozone.net All Rights Reserved
07/10/2007 21.29.46 WIB
---------------------------------------------------------
Sorting merupakan suatu proses untuk menyusun kembali humpunan obyek menggunakan aturan tertentu. Sorting disebut juga sebagai
suatu algoritma untuk meletakkan kumpulan elemen data kedalam urutan
tertentu berdasarkan satu atau beberapa kunci dalam tiap-tiap elemen.
Pada dasarnya ada dua macam urutan yang biasa digunakan dalam suatu
proses sorting:
1. urut naik (ascending)
Mengurutkan dari data yang mempunyai nilai paling kecil sampai paling besar
2. urut turun (descending)
Mengurutkan dari data yang mempunyai nilai paling besar sampai paling kecil.
Mengapa harus melakukan sorting data? Ada banyak alasan dan keuntungan
dengan mengurutkan data. Data yang terurut mudah untuk dicari, mudah
untuk diperiksa, dan mudah untuk dibetulkan jika terdapat kesalahan.
Data yang terurut dengan baik juga mudah untuk dihapus jika
sewaktu-waktu data tersebut tidak diperlukan lagi. Selain itu, dengan
mengurutkan data maka kita semakin mudah untuk menyisipkan data atapun
melakukan penggabungan data.
Well, metode-metode sorting yang akan saya bahas kali ini meliputi:
1. Insertion Sort (Metode Penyisipan)
2. Selection Sort (Metode Seleksi)
3. Bubble sort(Metode Gelembung)
4. Shell Sort (Metode Shell)
5. Quick Sort (Metode Quick)
6. Merge Sort (Metode Penggabungan)
1. Insertion Sort (Metode Penyisipan)
---( Straight Insertion Sort (Metode Penyisipan langsung)
Proses pengurutan dengan metode penyisipan langsung dapat dijelaskan sebagai berikut :
Data
dicek satu per satu mulai dari yang kedua sampai dengan yang terakhir.
Apabila ditemukan data yang lebih kecil daripada data sebelumnya, maka
data tersebut disisipkan pada posisi yang sesuai.
Akan lebih mudah apabila membayangkan pengurutan kartu. Pertama-tama
anda meletakkan kartu-kartu tersebut di atas meja, kemudian melihatnya
dari kiri ke kanan. Apabila kartu di sebelah kanan lebih kecil daripada
kartu di sebelah kiri, maka ambil kartu tersebut dan sisipkan di tempat
yang sesuai.
Algoritma penyisipan langsung dapat dituliskan sebagai berikut :
1. i = 1
2. selama (i < N) kerjakan baris 3 sampai dengan 9
3. x = Data[i]
4. j = i – 1
5. selama (x < Data[j]) kerjakan baris 6 dan 7
6. Data[j + 1] = Data[j]
7. j = j – 1
8. Data[j+1] = x
9. i = i + 1
Di bawah
ini merupakan prosedur yang menggunakan metode penyisipan langsung:
void StraighInsertSort()
{
int i, j, x;
for(i=1; i<Max; i++)
{
x = Data[i];
j = i - 1;
while (x < Data[j])
{
Data[j+1] = Data[j];
j--;
} Data[j+1] = x;
} }
---( Binary Insertion Sort (Metode Penyisipan Biner)
Metode ini merupakan pengembangan dari metode penyisipan langsung.
Dengan cara penyisipan langsung, perbandingan selalu dimulai dari
elemen pertama (data ke-0), sehingga untuk menyisipkan elemen ke i
kita harus melakukan perbandingan sebanyak i- 1 kali. Ide dari
metode ini didasarkan pada kenyataan bahwa pada saat menggeser data
ke-i, data ke 0 s/d i-1 sebenarnya sudah dalam keadaan terurut.
Algoritma penyisipan biner dapat dituliskan sebagai berikut :
1. i = 1
2. selama (i < N) kerjakan baris 3 sampai dengan 14
3. x = Data[i]
4. l = 0
5. r = i – 1
6. selama (l<=r) kerjakan baris 7 dan 8
7. m = (l + r) / 2
8. jika (x < Data[m]) maka r = m – 1, jika tidak l = m + 1
9. j = i – 1
10. selama ( j >=l) kerjakan baris 11 dan 12
11. Data[j+1] = Data[j]
12. j = j – 1
13. Data[l] = x
14. I = i + 1
Di bawah ini merupakan prosedur yang menggunakan metode penyisipan
biner:
void BinaryInsertSort()
{
int i, j, l, r, m, x;
for (i=1; i<Max; i++){
x = Data[i];
l = 0;
r = i - 1;
while(l <= r){
m = (l + r) / 2;
if(x < Data[m])
r = m - 1;
else
l = m + 1;
}
for(j=i-1; j>=l; j--)
Data[j+1] = Data[j];
Data[l]=x;
}
}
2. Selection Sort (Metode Seleksi)
Metode seleksi melakukan pengurutan dengan cara mencari data yang
terkecil kemudian menukarkannya dengan data yang digunakan sebagai
acuan atau sering dinamakan pivot. Proses pengurutan dengan metode
seleksi dapat dijelaskan sebagai berikut :
Langkah pertama dicari data terkecil dari data pertama sampai data
terakhir. Kemudian data terkecil ditukar dengan data pertama. Dengan
demikian, data pertama sekarang mempunyai nilai paling kecil
dibanding data yang lain. Langkah kedua, data terkecil kita cari
mulai dari data kedua sampai terakhir. Data terkecil yang kita
peroleh ditukar dengan data kedua dan demikian seterusnya sampai
semua elemen dalam keadaan terurutkan.
Algoritma seleksi dapat dituliskan sebagai berikut :
1. i = 0
2. selama (i < N-1) kerjakan baris 3 sampai dengan 9
3. k = i
4. j = i + 1
5. Selama (j < N) kerjakan baris 6 dan 7
6. Jika (Data[k] > Data[j]) maka k = j
7. j = j + 1
8. Tukar Data[i] dengan Data[k]
9. i = i + 1
Di bawah ini merupakan prosedur yang menggunakan metode seleksi:
void SelectionSort()
{
int i, j, k;
for(i=0; i<Max-1;i++)
{
k = i;
for (j=i+1; j<Max; j++)
if(Data[k] > Data[j])
k = j;
Tukar(&Data[i], &Data[k]);
}
}
3. Bubble sort(Metode Gelembung)
Metode gelembung (bubble sort) sering juga disebut dengan metode
penukaran (exchange sort) adalah metode yang mengurutkan data dengan
cara membandingkan masing-masing elemen, kemudian melakukan
penukaran bila perlu. Metode ini mudah dipahami dan diprogram,
tetapi bila dibandingkan dengan metode lain yang kita pelajari,
metode ini merupakan metode yang paling tidak efisien.
Proses pengurutan metode gelembung ini menggunakan dua kalang.
Kalang pertama melakukan pengulangan dari elemen ke 2 sampai dengan
elemen ke N-1 (misalnya variable i), sedangkan kalang kedua
melakukan pengulangan menurun dari elemen ke N sampai elemen ke i (misalnya
variable j). Pada setiap pengulangan, elemen ke j-1 dibandingkan
dengan elemen ke j. Apabila data ke j-1 lebih besar daripada data ke
j, dilakukan penukaran.
Algoritma gelembung dapat dituliskan sebagai berikut :
1. i = 0
2. selama (i < N-1) kerjakan baris 3 sampai dengan 7
3. j = N - 1
4. Selama (j >= i) kerjakan baris 5 sampai dengan 7
5. Jika (Data[j-1] > Data[j]) maka tukar Data[j-1] dengan Data[j]
6. j = j – 1
7. i = i + 1
Di bawah ini merupakan prosedur yang menggunakan metode gelembung:
void BubbleSort()
{
int i, j;
for(i=1; i<Max-1; i++)
for(j=Max-1; j>=i; j--)
if(Data[j-1] > Data[j])
Tukar(&Data[j-1], &Data[j]);
}
4. Shell Sort (Metode Shell)
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;
} } } } }
5. Quick Sort (Metode Quick)
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);
}
6. Merge Sort (Metode Penggabungan)
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;
}
...oO0---( Mana yang terbaik?
Tidak ada algoritma terbaik untuk setiap situasi yang kita hadapi,
bahkan cukup sulit untuk menentukan algoritma mana yang paling baik
untuk situasi tertentu karena ada beberapa faktor yang mempengaruhi
efektifitas algoritma pengurutan. Beberapa faktor yang berpengaruh
pada efektifitas suatu algoritma pengurutan antara
lain:
1. Banyak data yang diurutkan.
2. Kapasitas pengingat apakah mampu menyimpan semua data yang kita
miliki.
3. Tempat penyimpanan data.
---( Attachment: sorting.c
Berikut ini adalah implementasi dari keenam metode sorting diatas.
Data yang akan disorting dibangkitkan secara random. Ubah-ubahlah
nilai N pada program berikut untuk mengetahui perbedaan kecepatan
tiap-tiap metode. Semakin besar anda memberikan nilai N, semakin
terlihat perbedaan waktunya.

/* ------------------------------|EOF|------------------------------ */
|