Pengurutan
Tingkat Lanjut
Quick Sort
Algoritma :
void QuickSort(int Kiri, int Kanan)
{
if (Kiri < Kanan){
Atur elemen-elemen;
R[Kiri],...,R[Kanan] sehingga
menghasilkan urutan baru sbb.:
R[Kiri],...,R[J-1] < R[J] dan
R[J+1],...,R[Kanan] > R[J].
QuickSort(Kiri, J-1);
QuickSort(J+1, Kanan);
}
}
Pola Pergerakan Elemen pada
QuickSort
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
73 79 76 72 75 78 71 77 74
J=1
TUKAR
QS(0,8)
K=
6
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
73 71 76 72 75 78 79 77 74
J=2
K=3
TUKAR
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
73 71 72 76 75 78 79 77 74
K=2
TUKAR
J=3
R[0] R[1] R[2] R[3] R[4 R[5] R[6] R[7] R[8]
72 71 73 76 75 78 79 77 74
K=1
TUKAR
J=2
QS(0,1)
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 76 75 78 79 77 74 QS(0,0)
QS(2,1)
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 76 75 78 79 77 74 QS(3,8)
J=5
TUKAR
K=8
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 76 75 74 79 77 78
K=5
J=6
TUKAR
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 74 75 76 79 77 78
QS(3,4)
QS(3,2)
QS(4,4)
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 74 75 76 79 77 78
K=8
QS(6,8)
J=?
TUKAR
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 74 75 76 78 77 79
QS(6,7)
K=7 J=8
TUKAR
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 74 75 76 77 78 79
R[0] R[1] R[2] R[3] R[4] R[5] R[6] R[7] R[8]
71 72 73 74 75 76 77 78 79
QS(6,6)
QS(8,7)
QS(9,8)
Skema Pemanggilan QS
(Kiri, Kanan) secara Rekursif
QS(0,8)
QS(3,8)
QS(0,1)
QS(0,0)
QS(2,1)
QS(3,4)
QS(3,2)
QS(6,8)
QS(4,4)
QS(6,7)
QS(6,6)
void QuickSort (int L, int R)
{
int j,k;
if (L < R){
j = L; k = R + 1;
do {
QS(9,8)
QS(8,7)
do { j=j+1;} while (Arr[j] < Arr[L]);
do { k=k-1;} while (Arr[k] > Arr[L]);
if (j < k) Tukar(&Arr[j],&Arr[k]);
} while (j <= k);
Tukar(&Arr[L], &Arr[k]);
QuickSort(L,k-1);
QuickSort(k+1,R);
}
}
Merge Sort
Natural Merge antara list L1 dan L2 terjadi
bila data di L1 maupun di L2 telah terurut.
L1 :
L2 :
09
10
14
12
16
19
18
40
24
52
30
77
List L3 merupakan hasil merge antara list L1
dengan list L2.
L3 : 09 10 12 14 16 18 19 24 30 52 77
RUN
  Adalah sebagian dari list, dimana data
telah terurut.
Contoh :
List X sbb:
34 36 23 12 16 18 24 10
List X mula-mula mengandung 8 Run, yaitu :
Run1
Run2
Run3
Run4
: 34
: 36
: 23
: 12
Run5
Run6
Run7
Run8
: 16
: 18
: 24
: 10
Lakukan merge untuk setiap Run pada list X
(Run1 dgn Run2, Run3 dgn Run4, Run5 dgn
Run6, Run7 dgn Run8) dan simpan di list R.
R : 34 36  12 23  16 18  10 24
Sekarang List R terdiri dari 4 Run yang
masing-masing sudah terurut yaitu:
Run1 : 34 36
Run2 : 12 23
Run3 : 16 18
Run4 : 10 24
Copy List R ke List X, dan Lakukan merge
untuk setiap Run pada list X (Run1 dgn
Run2, Run3 dgn Run4) dan simpan di list R.
R : 12 23 34 36  19 16 18 24
Sekarang List R terdiri dari 2 Run yang
masing-masing sudah terurut, dan yang
terjadi sekarang adalah Natural Merge.
Run1 : 12 23 34 36
Run2 : 10 16 18 24
Copy List R ke List X, dan Lakukan merge
untuk setiap Run pada list X (Run1 dgn
Run2) dan simpan di list R.
R : 10 12 16 18 23 24 34 36
Sekarang list R terdiri dari satu Run dan
sudah terurut. Copy list R ke List X.
34 36 23 12 16 18 24 10
34 36 12 23 16 18 10 24
12 23 34 36 10 16 18 24
10 12 16 18 23 24 34 36
/* Fungsi MergeSort.
X adalah Array dengan n elemen */
void mergesort (int *X, int n)
{
int *R, i, j, k, l1, l2, size, u1, u2;
R = (int*)malloc(n*sizeof(int));
size = 1;
while (size < n) {
l1=0; k=0;
while (l1+size < n) {
l2 = l1 + size;
u1 = l2 - 1;
u2 = (l2+size-1 < n) ? l2+size-1 : n-1;
for (i=l1, j=l2; i<=u1 && j<=u2; k++) {
if (X[i] <= X[j])
R[k] = X[i++];
else
R[k]=X[j++];
}
for ( ; i <= u1; k++) R[k] = X[i++];
for ( ; j <= u2; k++) R[k] = X[j++];
l1 = u2+1;
}
for (i=l1;k < n; i++) R[k++] = X[i];
for (i=0; I < n; i++) X[i]=R[i];
size *= 2;
}
free ( R );
}
LATIHAN :
1. 1. Buat fungsi Tukar pada fungsi
QuickSort diatas, kemudian buat main
programnya untuk memanggil fungsi
QuickSort tersebut.
2. 2. Buat main program untuk memanggil
fungsi MergeSort diatas.