Slide 1

AlgoritmaPengurutan/Sorting (bab 2)

TujuanPembelajaran
Memahami konsep dari algoritma bubblesort
Memahami konsep dari algoritma quicksort
Memahami tentang perbandingan kinerja darimasing-masing algoritma sorting

Slide 2

Apa itu Sorting ?

(Untuk Dibaca :
Sorting adalah sebuah teknik pemrogramanuntuk mengurutkan suatudata.
Teknik ini bisa menjadi langkah awal untuk melakukan pencarian karena sebuah pencarian dari data yang telah
diurutkan sangat lebih cepat dibandingkan dengan pencarian linier. Banyak sekali teknik-teknik dari algoritma
Pencarian ini )

Sorting Memiliki Banyak Jenis Diantaranya :

BubbleSort,
Selection Sort,
InsertionSort,
MergeSort,
Shellsort,
Quicksort
dan lain sebagainya.

Slide 3

#1 Bubble Sort
Ide dari algoritma bubble sort adalah mengulang proses pembandingan antara tiap-tiap elemen array dan
menukarnya apabila urutannya salah.
Teknik ini menyusun data yang diinginkan secara berurutan dengan membandingkan elemen data yang ada dan terus
diulang hingga tidak perlu dilakukan penukaran lagi.
Pengurutan merupakan proses dasar yang ada dalam algoritma dan stuktur data. Terdapat banyak algoritma
pengurutan yang sering digunakan, namun kali ini akan dibahas mengenai dasar algoritma Bubble Sort.
Algortima ini merupakan algortima pengurutan sederhana dan biasanya dipelajari sebagai pokok bahasan seputar
pengurutan.
Algoritma Bubble Sort ini merupakan proses pengurutan yang secara berangsur-angsur berpindah ke posisi yang
tepat karena itulah dinamakan Bubble yang artinya gelembung. Algoritma ini akan mengurutkan data dari yang
terbesar ke yang terkecil (ascending) atau sebaliknya (descending).
Secara sederhana, bisa didefenisikan algoritma Bubble Sort adalah pengurutan dengan cara pertukaran data dengan
data disebelahnya secara terus menerus sampai dalam satu iterasi tertentu tidak ada lagi perubahan.
Berikut ini adalah gambaran dari algoritma bubble sort:

for i:=1 to Jumlah_data-1 do

for j:=i+1 to Jumlah_data do
if Data[i]>Data[j] then
begin
t:=Data[i];
Data[i]:=Data[j];
Data[j]:=t;
end;
Kita misalkan memiliki 5 angka yang akan kita simpan kedalam variabel Data (Array).
Dengan masing-masing nilai sebagai berikut:

Data[1] := 3;
Data[2] := 1;
Data[3] := 4;
Data[4] := 2;
Data[5] := 6;
Cara Kerja:
Langkah pertama: Data[1] akan dibandingkan dengan Data[2]. Jika Data[1] lebih besar dari Data[2] maka nilai dari
kedua variabel tersebut ditukar posisinya.
Data[1] akan terus dibandingkan dengan data-data selanjutnya (Data[3], Data[4], dan Data[5]). Hingga
akhirnya Data[1] berisi nilai terkecil.
Setelah proses perbandingan Data[1] selesai, selanjutnya kita akan
membandingkan Data[2] dengan Data[3], Data[4] dan Data[5] seperti proses sebelumnya.
Begitu seterusnya sampai semua data selesai di bandingkan.

Berikut adalah contoh program pascal dengan agoritma buble sort: (1)

Program Bubble_Urutan;
uses crt;
var Data:array[1 .. 5] of integer;
i,j,t,Jumlah_data:integer;
Begin
Data[1] := 3;
Data[2] := 1;
Data[3] := 4;
Data[4] := 2;
Data[5] := 6;
Jumlah_data := 5;

writeln('Data Awal:');
for i:=1 to Jumlah_data do
begin
writeln('Data[',i,'] = ',Data[i]);
end;

for i:=1 to Jumlah_data-1 do

for j:=i+1 to Jumlah_data do
if Data[i]>Data[j] then
begin
t:=Data[i];
Data[i]:=Data[j];
Data[j]:=t;
 end;

writeln('Hasil:');
for i:=1 to Jumlah_data do
begin
writeln('Data[',i,'] = ',Data[i]);
end;

End.

CONTOH CODING BUBBLE SORT 2 (Ascending)

#include<iostream>
using namespace std;

int main()
{ int a,k,c,d,g;
k=4;
int b[4];

cout<<"BUBBLE SORT BY ZEFTAADETYA.BLOGSPOT.COM"<<endl;

cout<<"mengurutkan nilai dari besar ke kecil"<<endl<<endl;
for(a=0;a<k;a++)
{
cout<<"Masukkan nilai "<<a+1<<" : ";cin>>b[a];
}
for(a=0;a<k-1;a++)
{

for(d=a+1;d<k;d++)
{
c=a;
if(b[c]<b[d])
{
c=d;
}
g=b[c];
b[c]=b[a];
b[a]=g;
}

}
cout<<"\n setelah diurutkan akan menjadi : \n";
for(a=0;a<k;a++)
{
cout<<b[a]<<" \n";
}
}
(Contoh Penjelasan Logika Nya)

Untuk belajar algoritma Bubble Sort ini kita hanya perlu memahami cara yang digunakan untuk mengurutkan data,
sederhananya algoritma ini menggunakan perbandingan dalam operasi antar elemennya. Di bawah ini merupakan
gambaran dari algoritma Bubble Sort dengan array “3 1 4 2 8”.
Proses pertama
(3 1 4 2 8) menjadi (1 3 4 2 8)
(1 3 4 2 8) menjadi (1 3 4 2 8)
(1 3 4 2 8) menjadi (1 3 2 4 8)
(1 3 2 4 8) menjadi (1 3 2 4 8)

Proses kedua
(1 3 2 4 8) menjadi (1 3 2 4 8)
(1 3 2 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
Proses ketiga
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
(1 2 3 4 8) menjadi (1 2 3 4 8)
Jika kita perhatikan proses diatas, para proses kedua data sudah terurut dengan benar. Tetapi algoritma Bubble Sort
tetap berjalan hingga proses kedua berakhir. Proses ketiga masih terus berjalan karena pada algoritma Bubble Sort
maksud terurut itu adalah tidak ada satupun penukaran pada suatu proses. Proses ketiga ini dilakukan untuk
verifikasi data.
Algoritma Bubble Sort ini mempunyai kelebihan dan kekurangan, untuk kelebihannya metode ini merupakan
metode paling sederhana untuk mengurutkan data. Selain sederhana, algoritma Bubble Sort mudah dipahami.
Sementara itu, kekurangannya terletak pada efisiensi.
Bubble Sort ini merupakan metode pengurutan yang tidak efisien karena ketika mengurutkan data yang sangat besar
akan sangat lambat prosesnya. Selain itu, jumlah pengulangan akan tetap sama jumlahnya meskipun data sudah
cukup terurut.
1. METODE QUICK SORT

Algoritma quicksort diperkenalkan pertama kali oleh C.A.R. Hoare pada tahun 1960, dan dimuat sebagai
artikel di Computer Journal 5 pada April 1962. Bentuknya yang sederhana, efisien dan efektif dengan cepat
membuatnya menjadi algoritma pengurutan (sorting) yang paling banyak digunakan, terutama dalam bahasa
pemrograman.

Contoh Program Quick Sort.

Quick sort pemrograman JAVA
public class QuickSort {
/*
created by kang ono
https://onophp.blogspot.com/
*/
static void quickSort (int a[], int lo, int hi){
// lo adalah index bawah, hi adalah index atas
// dari bagian array yang akan di urutkan
int i=lo, j=hi, h;
int pivot=a[lo];
// pembagian
do{
while (a[i]<pivot) i++;
while (a[j]>pivot) j--;
if (i<=j)
{
h=a[i]; a[i]=a[j]; a[j]=h;//tukar
i++; j--;
}
} while (i<=j);
// pengurutan
if (lo<j) quickSort(a, lo, j);
if (i<hi) quickSort(a, i, hi);
}

public static void main(String[] args) {

int tabInt[]={9,4,2,7,10,1,5};
int i,n=7;
System.out.print("data sebelum di urutkan\n");
for(i=0;i<n;i++){
System.out.print(tabInt[i]+ " ,");
}
System.out.print("\n");
 quickSort(tabInt,0,n-1);
System.out.print("\nsetelah di urutkan dengan quick sort\n");
for(i=0;i<n;i++){
System.out.print(tabInt[i]+" , ");
}
}
}

Contoh Pengurutan Quick Short

dalam hal ini saya punya angka sebagai berikut.

 langkah pertama adalah tentukan pivotnya. dalam hal ini adalah saya memilih angka 7

 kemudian buatpartisi buat masing2 angka sebelah kanan dan kiri

 kemudian gunakan algoritma quicksort yang ada diatas. jika angka lebih kecil dari pivot maka akan
diletakan sebelah kiri dan jika lebih besar maka letakan disebelah kanan. langkah pertama adalah bandingkan angka
9 dengan pivot apakah lebih kecil atau lebih besar.
 karena angka 9 lebih besar maka letakan angka 9 setelah pivot.

 lanjut ke angka 4. bandingkan angka 4 dengan pivot.

 karena angka 4 lebih kecil dari 7 maka posisi tetap.

 lanjut ke angka 2. cek apakah angka 2 lebih kecil atau lebih besar dari pivot.
 karena angka 2 lebih kecil dari pivot maka letaknya tetap

 bandingkan pivot dengan angka 10. cek angka 10 ebih besar atau lebih kecil dari pivot.

 karena angka 10 lebih besar maka posisi tetap sebelah kanan

 lanjut ke angka 1. cek angka 1 lebih kecil atau lebih besar dari pivot.
 karena lebih kecil maka pindah ke sebelah kiri pivot.

 lanjut ke angka 5. cek apakah angka 5 lebih kecil atau lebih besar dari angka pivot.

 karena angka 5 lebih kecil maka pindah ke sebelah kiri pivot.

 setelah itu masuk ke dalam partisi baru. sampai sini proses belum selesai.
 tentukan pivot untuk masing-masing partisi

 perbandingan untuk pivot pertama. angka 2. cek apakah angka 2 lebih kecil atau lebih besar dari pivot.

 karena angka 2 lebih kecil dari pivot maka pindahkan ke kiri pivot.

 lanjut ke angka 1. cek apakah angka lebih besar atau lebih kecil dari pivot.
 karena angka 1 lebih kecil maka pindahkan disebelah kiri angka pivot.

 lanjut ke angka 5. cek apakah angkanya lebih besar atau lebih kecil dari pivot.

 karena lebih besar maka posisinya tetap. untuk partisi pertama selesai

 ulangi langkah2 seperti sebelumnya untuk pivot partisi ke 2. dan hasil akhir dari quick sort ini adalah
seperti ini :
Kelebihan dan Kelemahan Algoritma Quick Sort
Beberapa hal yang membuat quick sort unggul:

 Secara umum memiliki kompleksitas O(n log n).

 Algoritmanya sederhana dan mudah diterapkan pada berbagai bahasa pemrograman dan arsitektur
mesin secara efisien.
 Dalam prakteknya adalah yang tercepat dari berbagai algoritma pengurutan dengan perbandingan,
seperti merge sort dan heap sort.
 Melakukan proses langsung pada input (in-place) dengan sedikit tambahan memori.
 Bekerja dengan baik pada berbagai jenis input data (seperti angka dan karakter).
Namun terdapat pula kelemahan quick sort:

 Sedikit kesalahan dalam penulisan program membuatnya bekerja tidak beraturan (hasilnya tidak
benar atau tidak pernah selesai).
 Memiliki ketergantungan terhadap data yang dimasukkan, yang dalam kasus terburuk memiliki
kompleksitas O(n2).
 Secara umum bersifat tidak stable, yaitu mengubah urutan input dalam hasil akhirnya (dalam hal
inputnya bernilai sama).
 Pada penerapan secara rekursif (memanggil dirinya sendiri) bila terjadi kasus terburuk dapat
menghabiskan stack dan memacetkan program.
Implementasi Algoritma Quick Sort
LINKEDLIST (JAVA)
Daftar berantai (bahasa Inggris: linked list) atau kadang–
kadang disebut dengan daftar bertaut atau checkbertaut dalam ilmu komputer adalah sebu
ah struktur data yang digunakan untuk menyimpan sejumlah objekdata biasanya secara te
rurut sehingga memungkinkan penambahan, pengurangan, dan pencarian atas elemendata
yang tersimpan dalam daftar dilakukan secara lebih efektif. Pada prakteknya sebuah stru
ktur data memilikielemen yang digunakan untuk saling menyimpan referensi antara satu
dengan lainnya sehingga membentuksebuah daftar abstrak, tiap–
tiap elemen yang ada pada daftar abstrak ini seringkali disebut sebagai node. karenameka
nisme rujukan yang saling terkait inilah disebut sebagai daftar berantai.

Sebuah senarai berantai dengan tiap-tiap node yang terdiri atas dua elemen, data integer, dan elemen rujukan ke node
berikutnya

Senarai berantai merupakan bentuk struktur data paling umum dan sederhana yang
banyak digunakan untuk mengimplementasikan model struktur data lainnya, termasuk
antrian, stack, ataupun larik assosiatif.

Keuntungan dan kerugian

Keuntungan utama pemanfaatan daftar berantai dibandingkan larik, atau daftar biasa adal
ah fasilitas danefektifitas kerja yang lebih baik dalam hal menambah, mengurangi, serta
menemukan suatu elemen / node yangada dalam daftar. Hal tersebut dimungkinkan karen
a elemen–
elemen yang ada pada sebuah daftar berantaitidak ditempatkan pada sebuah blok memori
komputer seperti halnya larik atau daftar biasa, melainkan tiap–
tiap elemen / node tersebut tersimpan dalam blok memori terpisah, penambahan, pengura
ngan, ataupenggantian node dapat dilakukan dengan mengubah elemen referensi atas tiap
–
tiap node yang terkait. Kerugiannya, sebuah daftar berantai tidak memungkinkan pengaks
esan elemen secara
acak, dalam artian untukdapat mengakses node ke tiga pada contoh di atas harus dilakuka
n dengan cara mengunjungi elemen–
elemen sebelumnya, dimulai dari elemen pertama, ke dua, seterusnya sampai pada lokasi
elemen yang dimaksudkan.
Jenis–jenis daftar berantai
daftar tunggal
Bila struktur data sebuah node hanya memiliki satu tautan atas node berikutnya dalam se
buah daftar, makadaftar tersebut dinamakan sebagai daftar tunggal.

Senarai tunggal dengan tiap-tiap node yang terdiri atas dua elemen, data integer, dan elemen rujukan ke node berikutnya
daftar ganda
Berbeda halnya dengan daftar tunggal, pada daftar ganda, struktur data atas tiap–
tiap node memiliki referensipada node sebelum dan berikutnya. Sebagian algoritma mem
butuhkan taut ganda, misalnya sorting dan reversetraversing.

Senarai ganda dengan tiap-tiap node yang terdiri atas tiga elemen, data integer, dan dua elemen rujukan ke node sebelum
serta berikutnya
daftar sirkular Pada dua jenis daftar sebelumnya, node terakhir dalam daftar tersebut me
ngacu pada null yangartinya akhir dari sebuah daftar, begitu pula null sebagai referensi n
ode sebelumnya pada node pertama biladaftar yang dimaksudkan adalah daftar ganda. Pa
da daftar sirkular, informasi referensi pada node terakhir akanmengacu pada node pertam
a, dan referensi pada node pertama akan mengacu pada node terakhir bila yangdigunakan
sebagai dasar implementasi adalah daftar ganda.

Senarai sirkular dengan menggunakan model implementasi senarai tungal. Node terakhir menyimpan rujukan pada node
pertama
contoh program :
package pck_03;import java.util.LinkedList;public class linked_list_simple {
public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList<String> lList = new LinkedList<String>();
lList.add(“1″);
lList.add(“2″);
lList.add(“3″);
lList.add(“4″);
lList.add(“5″);
if (lList.size()==0){
System.out.println(“Linked list is empty”);
}
else{
System.out.println( “Linked list size: ” + lList.size());
}
// print LinkedList
System.out.println(“LinkedList contains : ” + lList);
}

outputnya :
contoh program :
package pck_03;import java.util.LinkedList;public class linked_list3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList<String> lList = new LinkedList<String>();
lList.add(“1″);
lList.add(“2″);
lList.add(“3″);
lList.add(“4″);
lList.add(“5″);
System.out.println(“Delete the third element!”);
lList.remove(3); // delete the third elemet
System.out.println(“The contents of array are” + lList);
System.out.println(“The size of linkedlist is “+ lList.size());
}

outputnya :