1

PROGRAM PENGURUTAN (SORTING)

Beberapa metode pengurutan internal, 3 diantaranya adalah :
Maximum Sort, Insertion Sort dan Bulle sort.
Berikut adalah deskripsi dan langkah-langkah dari masing-masing metode.
Maximum Sort
Disebut pengurutan maksimum karena didasarkan pada pemilihan elemen maksimum
kemudian mempertukarkan elemen maksimum tersebut dengan elemen terujung larik
(ujung kiri atau kanan). Selanjutnya elemen terujung tersebut “diisolasi” dab tidak
disertakan pd proses selanjutnya. Proses yang sama diulang untuk elemen larik yang
tersisa.
Lanakah-langkah pengurutan data agar terurut MENAIK adalah
langkah 1 : Tentukan harga maksimum di L[1..N]
Penukaran harga maksimum dg elemen L[N]
langkah 2 : Tentukan harga maksimum di L[1..N-1]
Penukaran harga maksimum dg elemen L[N-1]
langkah 3 : Tentukan harga maksimum di L[1..N-2]
Penukaran harga maksimum dg elemen L[N-2]
……………
langkah N-1 : Tentukan harga maksimum di L[1..2]
Penukaran harga maksimum dg elemen L[2]
(elemen yg tersisa adalah L[1], tidak perlu diurut karena hanya satu-satunya)

2
Algoritma prosedur pengurutan dengan metode Maximum Sort adalah sbb :
Procedure MaxSort(input/output L : Larik, input N : integer)
{mengurutkan elemen Larik L[1..N] sehingga tersusun MENAIK dg metode pengurutan maksimum}
{Kondisi awal : lemen larik L sudah terdefinis harganya}
{Kondisi Akhir : Elemen larik L terurut MENAIK sedemikian sehingga L[1]  L[2]  ..  L[N]}

Kamus Lokal
I : integer {pencacah utk jumlah langkah}
J : integer {pencacah utk mencari nilai maksimum}
U : integer {indeks ujung kiri bagian larik yg telah terurut}
Maks : integer {nilai maksimum sementara}
Imaks : integer {indeks yg berisi nilai maksimum sementara}
Temp : integer {variabel bantu untuk pertukaran}
ALGORITMA
U := N
For I := 1 to N-1 do
Maks := L[1]
Imaks := 1
For j := 2 to U do
If L[j] > Maks then
Maks := L[j]
Imaks := j
Endif
Endfor
{pertukarkan Maks dengan L[U]}
Temp := L[U]
L[U] := L[Imaks]
L[Imaks} := Temp
{Larik L[U..N] terurut, larik [1..U-1] belum terurut}
U := U-1
endfor

3
Insertion Sort
Seperti metode sebelumnya, untuk larik berukuran N jumlah tahapan yang
dilakukan adalah N-1. Pencarian posisi yg tepat dimulai untuk elemen
kedua (ukuran larik >1), jk elemen pertama sudah pada tempatnya.
Misal larik akan diurun MENAIK. Pada setiap tahap ke-K, larik terdiri
atas dua bagian : bagian terurut yaitu L[1..K-1], dan bagian belum
terurut L[K..N]. Ambil elemen L[K} dan sisipkan pada posisi yang tepat
di dalam L[1..K-1] sedemikian sehingga [1..K] tetap terurut. Caranya
bandingkan L[K] dengan L[J], J=K-1, K-2, ….., 1. Jika L[K] < L[J], geser
L[J} ke L[J+1]. Posisi yang tepat ditemukan jika L[K]>L[J] atau J = 1,
sehingga ditempatkan pada posisi ke-(J+1).
Algoritma pengurutan dengan metode Insertion Sort adalah sbb :
Misal : L[1] dianggap sudah pada tempatnya
Langkah 2 : L[2] harus dicari tempatnya yang tepat pada L[1..2] dengan cara
menggeser elemen L[1..1] ke kanan bila L[1..1] lebih besar daripada
L[2]. Misalkan posisi yg tepat adalah K. Sisipkan L[2] pada L[K].
Langkah 3 : L[3] harus dicari tempatnya yang tepat pada L[1..3] dengan cara
menggeser elemen L[1..2] ke kanan bila [1..2] lebih besar dari pada
L[3]. Misalkan posisi yang tepat adakah K. Sisipkan L[3] pada L[k].
Langkah 4 : L[4] harus dicari tempatnya yang tepat pada L[1..4] dengan cara
menggeser elemen L[1..3] ke kanan bila [1..3] lebih besar dari pada
L[4]. Misalkan posisi yang tepat adakah K. Sisipkan L[4] pada L[k].
………..
Langkah N : L[N] harus dicari tempatnya yang tepat pada L[1..N-1] dengan
cara menggeser elemen L[1..N-1] ke kanan bila [1..N-1] lebih besar
dari pada L[4]. Misalkan posisi yang tepat adakah K. Sisipkan L[N]
pada L[k].
Hasil dari langkah N : Larik L[1..N] sudah terurut MENAIK

4
Algoritma prosedur pengurutan dengan metode Insertion Sort adalah sbb :
Procedure MaxSort(input/output L : Larik, input N : integer)
{mengurutkan elemen Larik L[1..N] sehingga tersusun MENAIK dg metode pengurutan maksimum}
{Kondisi awal : lemen larik L sudah terdefinis harganya}
{Kondisi Akhir : Elemen larik L terurut MENAIK sedemikian sehingga L[1]  L[2]  ..  L[N]}

Kamus Lokal
K : integer {pencacah utk jumlah langkah}
J : integer {pencacah utk penelusuran Larik}
Temp : integer {variabel bantu untuk pertukaran}
ALGORITMA
{elemen L[1] dianggap sudah terurut}
For K := 2 to N do {mulai dari langkah 2 sampai langkah N}
Temp := L[K]
{cari posisi yg tepat utk L[K] di dlm L[1..K-1] sambil menggeser}
J := K-1
While (Temp  L[J]) and (J>1) do
L[J+1] := L[J]
J := J-1
Endwhile
If Temp  L[J] then
L[J+1] := Temp
Else
L[J+1] := L[J]
L[J] := Temp
Endif
endfor

5
Bubble Sort

Idenya adalah gelembung air yang akan ‘mengapung’. Elemen berharga kecil
akan ‘diapungkan’, artinya diangkat ke atas melalui pertukaran.
Proses dilakukan sebanyak N langkah.
Langkah 1 :
–Mulai dr elemen K = N,N-1,…,2, bandingkan L[K] dengan L[K-1]. Jk
L[k]<L[k-1], pertukarkan L[k] dg L[k-1]. Pd akhir langkah 1, elemen
L[1] berisi harga minimum pertama.
Langkah 2 :
–Mulai dr elemen K = N,N-1,…,3, bandingkan L[K] dengan L[K-1]. Jk
L[k]<L[k-1], pertukarkan L[k] dg L[k-1]. Pd akhir langkah 2, elemen
L[2] berisi harga minimum kedua dan larik L[1..2] terurut
•
Langkah 3 :
–Mulai dr elemen K = N,N-1,…,4, bandingkan L[K] dengan L[K-1]. Jk
L[k]<L[k-1], pertukarkan L[k] dg L[k-1]. Pd akhir langkah 3, elemen
L[3] berisi harga minimum ketiga dan larik L[1..3] terurut
•
……
Langkah N-1 :
–Mulai dr elemen K = N, bandingkan L[K] dengan L[K-1]. Jk L[k]<L[k-1],
pertukarkan L[k] dg L[k-1].

6
Algoritma prosedur pengurutan dengan metode Bubble Sort adalah sbb :

Procedure BubbleSort(input/output L : Larik; input N : integer)

{mengurutkan larik L[1..N] shg terurut menaik dg metode pengurutan bubble}
{K.Awal : Elemen larik L sudah terdefinisi}
{K.Akhir : Elemen larik L terurut menaik sedemikian shg L[1]  L[2]  …  L[N]}
Kamus
I : integer {pencacah utk jml langkah}
K : integer {pencacah utk pengapungan pd setiap langkah}
temp : integer {peubah bantu utk pertukaran}
Algoritma
for I := 1 to N-1 do
for k := N downto I + 1 do
if L[k]< L[k-1] then {pertukarkan L[k]
dg L[k-1]}
Temp := L[k]
L[k] := l[k-1]
l[k-1] := temp
endif
endfor
endfor