• Bubble Sort

• Selection Sort
• Insertion Sort
• Quick Sort

2
 Sorting (Pengurutan)

• Sorting merupakan suatu proses

(operasi) yang mengurutkan data dalam
suatu urutan yang diberikan.
• Pengurutan dapat dilakukan secara
ascending (urut naik) dan descending
(urut turun)

3
 Contoh :

 Misal suatu array DATA berisi 8 elemen

sebagai berikut :
DATA : 77, 33, 44, 11, 88, 22, 66, 55

Setelah diurutkan :
DATA (ascending) : 11, 22, 33, 44, 55, 66, 77, 88

DATA (descending): 88, 77, 66, 55, 44, 33, 22, 11

4
 Bubble Sort

• Merupakan algoritma sorting yang paling mudah.

• Proses pengurutan secara berangsur-angsur
bergerak/berpindah ke posisinya yang tepat,
seperti gelembung.

5
 Bubble Sort
• Dimulai dari elemen terakhir (paling kanan)
kemudian dibandingkan dengan elemen depannya
(sebelah kirinya).
• Bubble Sort mengurutkan data dengan cara
membandingkan elemen sekarang dengan elemen
berikutnya.
– Jika elemen sekarang lebih besar dari elemen berikutnya
maka kedua elemen tersebut ditukar, jika pengurutan
ascending.
– Jika elemen sekarang lebih kecil dari elemen berikutnya,
maka kedua elemen tersebut ditukar, jika pengurutan
descending
6
 Bubble Sort
• Algoritma ini seolah-olah menggeser satu per satu
elemen dari kanan ke kiri atau kiri ke kanan,
tergantung jenis pengurutannya.
• Ketika satu proses telah selesai, maka bubble sort
akan mengulangi proses, demikian seterusnya.
• Kapan berhentinya? Bubble sort berhenti jika seluruh
array telah diperiksa dan tidak ada pertukaran lagi
yang bisa dilakukan, serta tercapai perurutan yang
telah diinginkan.

7
Ilustration Bubble Sort (1)

 Pada gambar disamping,

pegecekan dimulai dari
data yang paling akhir,
kemudian dibandingkan
dengan data di depannya,
jika data di depannya
lebih besar maka akan
ditukar.
Ilustration Bubble Sort (1)
Ilustration Bubble Sort (1)
Ilustration Bubble Sort (1)
Ilustration Bubble Sort (1)

12
 Ilustration Bubble Sort (2)
Data :
34,43,65,90,48,82,93,86,26,76,49,23,56,37

13
Ilustration Bubble Sort (2)

14
Ilustration Bubble Sort (2)

15
- Procedure Tukar
Procedure Tukar_Data (Var a, b : Word);
Var c :Word;
Begin
c := a;
a := b;
b := c;
End;
- Procedure Bubble Sort Ascending
Procedure Asc_Bubble (Var data : Array; JmlData : Integer);
Var i,j :Integer;
Begin
For I := 2 to JmlData do
For J := JmlData down to I do
If data[j] < data[j-1] then
TukarData (data[j], data[j-1]);
end;

• Untuk pengurutan secara descending anda hanya perlu menggantikan baris

ke-6 dengan berikut ini :
If data[j] > data[j-1] then
 Program Sorting_Bubble;
Uses Crt;
Const
Max = 5;
Type
Arr = Array[1..max] Of Byte;
Var
Data : Arr;
i : Byte;
Procedure Input;
Begin
Clrscr;
Writeln('Masukkan 5 Data ');
Writeln('=================');
For I:=1 To Max Do
 Begin
Write('Data Ke :',I,'=');Readln(Data[i]);
End;
Clrscr;
For i:=1 to Max Do
Write(Data[i],' ');
Writeln;
Writeln('=========================');
Writeln('Data Yang telah Diurutkan');
Writeln;
{ Readln;}
End;
Procedure Change (Var a,b :Byte);
Var c:Byte;
Begin
C:=a;a:=b;b:=c;
End;
 Procedure Asc_Bubble;
Var
P,Q : Byte;
Flag: Boolean;
Begin
Flag:=False;
P:=2;
While (P<Max) And (Not Flag) Do
Begin
Flag:=True;
For Q:=Max Downto P Do
If Data[Q]<Data[Q-1] Then
Begin
Change(Data[Q],data[Q-1]);
Flag:=False;
End;
Inc(i);
End;
Write(' Ascending ');
End;
 Procedure Desc_Bubble;
Var
P,Q : Byte;
Flag: Boolean;
Begin
Flag:=False;
P:=2;
While (P<Max) And (Not Flag) Do
Begin
Flag:=True;
For Q:=Max Downto P Do
If Data[Q]>Data[Q-1] Then
Begin
Change(Data[Q],data[Q-1]);
Flag:=False;
End;
Inc(i);
End;
Write('Descending ');
End;
 Procedure Output;
Begin
For I:=1 To Max Do
Write(Data[I],' ');
Writeln;
End;
Begin
Input;
Asc_Bubble; Output;
Desc_Bubble; OutPut;
Writeln;
Write('Tekan Enter Untuk Lanjut');
Readln;
End.
SELECTION SORT

Pengurutan Seleksi

23
 Selection Sort

• Merupakan kombinasi antara sorting dan

searching.
• Untuk setiap proses, akan dicari elemen-
elemen yang belum diurutkan yang memiliki
nilai terkecil (ascending) atau terbesar
(descending) kemudian akan dipertukarkan
ke posisi yang tepat di dalam array.

24
• Terdapat 4 variasi dalam pengurutan seleksi,
yaitu :
-Pengurutan naik: pemilihan maksimun,
ditempatkan dibagian akhir.
-Pengurutan naik: pemilihan minimum,
ditempatkan dibagian awal.
-Pengurutan turun: pemilihan maksimum,
ditempatkan dibagian awal.
-Pengurutan turun: pemilihan minimum,
ditempatkan dibagian akhir.
Ilustration (2)
Ilustration (2)
Ilustration (2)
Ilustration (2)
Ilustration (1)

30
- Procedure Selection Sort Ascending
Procedure Asc_Selection;
Var Min, Pos : Byte
Begin
For I := 1 to max-1 do
Begin
Pos := I;
For J := i+1 to max do
If data[j] < data[pos] then Pos := j;
If I < > Pos then TukarData (data[i], data[pos]);
End;
End;

Untuk pngurutan secara desending, anda hanya perlu mengganti baris

ke-8 sbb :
if data[pos] < data[j] then pos:=j;
INSERTION SORT

Pengurutan Sisip

32
 Insertion Sort
• Mirip dengan cara mengurutkan kartu.
• Pengurutan dimulai dari data ke-2 sampai
dengan data terakhir, jika ditemukan data
yang lebih kecil, maka akan ditempatkan
(di-insert) diposisi yang seharusnya.
• Terjadi pergeseran data ke belakang.
Ilustration (1)
Ilustration (1)
Ilustration (1)
Ilustration (1)
Ilustration (1)
Ilustration (2)
- Procedure Insertion Sort Ascending
Procedure Asc_Insert;
Var i,j, temp : Byte;
Begin
For I := 2 to max do
Begin
Temp := data[i];
J := i-1;
While (data[j]>temp) and (j>0) do
Begin
Data[j+1] := data[j];
Dec(j);
End;
Data[j+1] := temp;
End;
End;

Untuk pengurutan secara descending anda tinggal mengganti baris ke 8

dengan baris berikut ini :
While(data[j]<temp)and(j>0)do
QUICK SORT

41
 Quick Sort
• Membandingkan suatu elemen (disebut pivot) dengan elemen yang lain
dan menyusun sedemikian rupa sehingga elemen-elemen lain yang
kecil daripada pivot tersebut terletak di sebelah kirinya dan elemen-
elemen lain yang lebih besar daripada tersebut terletak pada sebelah
kanannya.
• Sehingga dengan demikian terbentuk dua sublist kiri dan kanan yang
kita anggap sebuah list baru dan kita kerjakan proses yang sama
sebelumnya. Demikian seterusnya sampai tidak terdapat sublist lagi.
Sehingga di dalamnya telah terjadi proses rekursif.
Bilangan yang di dalam kurung merupakan pivot
Persegi panjang yang digambarkan dengan garis terputus-putus menunjukkan sublist.
i bergerak dari sudut kiri ke kanan sampai mendapatkan nilai yang >= pivot.
j bergerak dari sudut kanan ke kiri sampai menemukan nilai yang < pivot.

Langkah 1 :

i berhenti pada index ke-1 karena langsung mendapatkan nilai yang > dari pivot (15).
j Berhenti pada index ke-6 karena juga langsung mendapatkan nilai yang < dari pivot.

Karena i < j maka data yang ditunjuk oleh I ditukar dengan data yang ditunjuk oleh j
sehingga menjadi :

2 10 15 3 8 22
 Langkah 2 :

i. berhenti pada index ke-3 (pivot) karena tidak menemukan bilangan yang > dari
pivot.
i. berhenti pada index k-5 menunjuk pada nilai yang < dari pivot.

Karena i < j maka data yang ditunjuk oleh i (pivot) ditukar dengan data yang ditunjuk
oleh j sehingga menjadi :
2 10 8 3 15 22
 Langkah 3 :

Proses yang sama seperti sebelumnya dilakukan terhadap 2 buah sublist yang baru
(ditandai dengan persegi panjang dengan garis terputus-putus).
Procedure Quick Sort dengan nilai tengah sebagai pembanding (pivot).

Procedure Asc_Quick(L,R : Integer);

Var
mid, i, j : integer;
begin
i:= L; j:=R mid := data[(L+R) div 2];
repeat
while data[i] < mid do inc(i);
while data[j] > mid do dec(j);
if i < j then
begin
change(data[i],data[j]);
inc(i); dec(j);
end;
until i > j;
if L < j then Asc_Quick(L , j);
if i > R then Asc_Quick(i , R);
end;
Untuk pengurutan secara descending, anda hanya perlu mengganti baris ke-6 & 7
sbb :
while data[j] < mid do inc(j);
while data[k] > mid do dec(k);
Program progquicksort;
uses crt;
type
tipelarik=string;
larikurut=array[1..100] of tipelarik;
procedure quicksort (var x:larikurut;
bawah,atas:word);
var
i,j:word;
sementara:tipelarik;
begin
while atas>bawah do
begin
i:=bawah;
j:=atas;
sementara:=x[bawah];
{memecah larik menjadi dua bagian}
while i<j do begin
while x[j]>sementara do j:=j-1;
x[i]:=x[j];
while (i<j) and (x[i]<=sementara) do i:=i+1;
x[j]:=x[i];
end;

x[i]:=sementara;
{urutkan rekursi}
quicksort(x, bawah, i-1);
bawah:=i+1;
end;
end;
var
data: larikurut;
n,i:word;
begin
clrscr;
write('Jumlah data yang akan diurutkan?');readln(n);
writeln;
writeln('Masukkan data:');
for i:=1 to n do begin
write('Data ke',i,'?');readln(data[i]);
end;
{urutkan dengan prosedure quicksort}
quicksort(data,1,n);
{tampilkan data yang telah urut}
writeln;
writeln('Data yang telah urut:');
writeln('---------------------');
for i:=1 to n do
writeln(data[i]);
readln;
end.