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)

 

 

 

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 {
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 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 {
k = i;
for (j=i+1; 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 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 {
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 {
if(T1[i] {
T3[t] = T1[i];
i++;
}
else
{
T3[t] = T2[j];
j++;
}t++;
}
if(i>J1)
for(i=j; i {
T3[t] = T2[i];
t++;
}
if(j>J2)
for(j=i; 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.