SORTING (PENGURUTAN)

PENGERTIAN
• Pengurutan data dalam struktur data sangat
penting untuk data yang bertipe data
numerik ataupun karakter sehingga
digunakan secara luas dalam aplikasi.
• Pengurutan dapat dilakukan secara
ascending (urut naik) dan descending (urut
turun)
• Pengurutan (Sorting) adalah proses
menyusun kembali data yang sebelumnya
telah disusun dengan suatu pola tertentu,
sehingga tersusun secara teratur menurut
aturan tertentu.
2
Pengertian
• Mengatur elemen berdasar urutan tertentu.
• Beberapa algoritma sorting telah dibuat karena
proses tersebut sangat mendasar dan sering
digunakan.
• Pengurutan data (sorting) didefinisikan sebagai
suatu proses untuk menyusun kembali himpunan
obyek menggunakan aturan tertentu.
• Menurut Microsoft Book-shelf, definisi algoritma
pengurutan adalah algoritma untuk meletakkan
kumpulan elemen data ke dalam urutan tertentu
berdasarkan satu atau beberapa kunci dalam tiap-
tiap elemen.
3
DUA MACAM URUTAN
• Ada dua macam urutan yang biasa
digunakan dalam proses
pengurutan yaitu:
Urut naik (ascending) yaitu dari data
yang mempunyai nilai paling kecil
sampai paling besar
Urut turun (descending) yaitu data
yang mempunyai nilai paling besar
sampai paling kecil.
4
CONTOH
• Data bilangan 5, 2, 6 dan 4

Dapat diurutkan naik menjadi

2, 4, 5, 6
atau
Diurutkan turun menjadi
6, 5, 4, 2.
5
MANFAAT
Keuntungan dari data yang terurut antara
lain :
• Data mudah dicari (misalnya dalam buku
telepon atau kamus bahasa), mudah untuk
dibetulkan, dihapus, disisipi atau digabungkan.
• Mudah melakukan pengecekan apakah ada
data yang hilang.
• Melakukan kompilasi program komputer jika
tabel-tabel simbol harus dibentuk.
• Mempercepat proses pencarian data yang
harus dilakukan berulang kali.
6
Faktor Yang Berpengaruh
Pada Efektifitas Sorting
• Banyak data yang diurutkan.
• Kapasitas pengingat apakah mampu
menyimpan semua data yang kita
miliki.
• Tempat penyimpanan data, misalnya
harddisk, flasdisk, CD

7
BUBBLE SORT
• Metode sorting termudah
• Diberi nama “Bubble” karena proses
pengurutan secara berangsur-angsur
bergerak/berpindah ke posisinya yang
tepat, seperti gelembung yang keluar
dari sebuah gelas bersoda.
• Bubble Sort mengurutkan data dengan
cara membandingkan elemen
sekarang dengan elemen berikutnya.
8
BUBBLE SORT
• Pengurutan Ascending :Jika elemen
sekarang lebih besar dari elemen
berikutnya maka kedua elemen
tersebut ditukar.
• Pengurutan Descending: Jika elemen
sekarang lebih kecil dari elemen
berikutnya, maka kedua elemen
tersebut ditukar.
• Algoritma ini seolah-olah menggeser
satu per satu elemen dari kanan ke kiri
atau kiri ke kanan, tergantung jenis
pengurutannya, asc atau desc.
9
BUBBLE SORT

• Ketika satu proses telah selesai, maka

bubble sort akan mengulangi proses,
demikian seterusnya sampai dengan
iterasi sebanyak n-1.
• Kapan berhentinya? Bubble sort
berhenti jika seluruh array telah
diperiksa dan tidak ada pertukaran lagi
yang bisa dilakukan, serta tercapai
perurutan yang telah diinginkan.

10
 Sorting
Given a set (container) of n elements
E.g. array, set of words, etc.
Suppose there is an order relation that can be
set across the elements
Goal Arrange the elements in ascending order

Start : 1 23 2 56 9 8 10 100
End : 1 2 8 9 10 23 56 100
 Bubble Sort
Simplest sorting algorithm
Idea:
1. Set flag = false
2. Traverse the array and compare pairs of two
elements
• 1.1 If E1  E2 - OK
• 1.2 If E1 > E2 then Switch(E1, E2) and set flag = true
3. If flag = true goto 1.
What happens?
 Bubble Sort
1 1 23 2 56 9 8 10 100
2 1 2 23 56 9 8 10 100
3 1 2 23 9 56 8 10 100
4 1 2 23 9 8 56 10 100
5 1 2 23 9 8 10 56 100
---- finish the first traversal ----
---- start again ----
6 1 2 23 9 8 10 56 100
7 1 2 9 23 8 10 56 100
8 1 2 9 8 23 10 56 100
9 1 2 9 8 10 23 56 100
---- finish the second traversal ----
---- start again ----
………………….
Pseudocode
procedure bubbleSort( A : list of sortable 
items )
   n = length(A)
   repeat 
     swapped = false
     for i = 1 to n­1 do
       if A[i­1] > A[i] then         
         swap( A[i­1], A[i] )
         swapped = true
       end if
     end for
   until not swapped
end procedure
 Implementation
void bubbleSort (Array S,  length n) {
boolean isSorted = false;
while(!isSorted) {
isSorted = true;
for(i = 0; i<n; i++) {
     if(S[i] > S[i+1]) {
int aux = S[i];
S[i] = S[i+1]; 
S[i+1] = aux;
  isSorted = false;
}
  }
} 
 Running Time for Bubble Sort
One traversal = move the maximum element
at the end
Traversal #i : n – i + 1 operations
Running time:
(n – 1) + (n – 2) + … + 1 = (n – 1) n / 2 = O(n
2
)
When does the worst case occur ?
Best case ?
BUBBLE SORT

19
BUBBLE SORT

20
INSERTION SORT
• Mirip dengan cara orang mengurutkan kartu,
selembar demi selembar kartu diambil dan
disisipkan (insert) ke tempat yang seharusnya.
• Pengurutan dimulai dari data ke-2 sampai dengan
data terakhir, jika ditemukan data yang lebih kecil,
maka akan ditempatkan (diinsert) diposisi yang
seharusnya.
• Pada penyisipan elemen, maka elemen-elemen lain
akan bergeser ke belakang

21
INSERTION SORT
• Salah satu algoritma paling sederhana
• Cukup intuitif dan prosesnya mirip dengan
mengurutkan kartu
– Tujuan: mengurutkan kartu dari paling kecil hingga
terbesar
– Terdapat: kartu, meja 1, meja 2
– Awal: Kartu acak diletakkan pada meja 1
– Teknik: Kartu berurutan diletakkan pada meja 2
– Ambil kartu pertama dari meja 1, bandingkan
dengan meja 2 dan tempatkan sesuai posisi urutan
di meja 2
– Ulangi hingga seluruh kartu terletak pada meja 2
22
INSERTION SORT
INSERTION SORT
25
26
Step 1 − If it is the first element, it is already sorted. return 1;
Step 2 − Pick next element
Step 3 − Compare with all elements in the sorted sub-list
Step 4 − Shift all the elements in the sorted sub-list that is
greater than the value to be sorted
Step 5 − Insert the value
Step 6 − Repeat until list is sorted
Pseudocode

for i ← 1 to length(A)­1
    j ← i
    while j > 0 and A[j­1] > A[j]
        swap A[j] and A[j­1]
        j ← j ­ 1
    end while
end for
SELECTION SORT
• Algoritma sorting yang lainnya
– Intuitif dan mudah diimplementasikan
• Juga mirip dengan cara lain dalam pengurutan kartu
– Tujuan: mengurutkan kartu secara ascending
– Diberikan: kartu, meja
– Awal: Kartu disebar secara acak pada meja
– Periksa nilai, kemudian pilih kartu dengan nilai terendah
– Tukarkan posisi kartu ini dengan kartu pertama pada meja
– Cari kartu dengan nilai terendah dari sisa kartu yang ada
– Tukarkan kartu terpilih dengan kartu pada posisi kedua
– Ulangi proses hingga kartu kedua sebelum terakhir pada
meja dibandingkan dan ditukar dengan kartu terakhir

29
SELECTION SORT
• Merupakan kombinasi antara sorting dan searching
• Untuk setiap proses, akan dicari elemen-elemen
yang belum diurutkan yang memiliki nilai terkecil
atau terbesar akan dipertukarkan ke posisi yang
tepat di dalam array.
• Misalnya untuk putaran pertama, akan dicari data
dengan nilai terkecil dan data ini akan ditempatkan
di indeks terkecil (data[0]), pada putaran kedua
akan dicari data kedua terkecil, dan akan
ditempatkan di indeks kedua (data[1]).
• Selama proses, pembandingan dan pengubahan
hanya dilakukan pada indeks pembanding saja,
pertukaran data secara fisik terjadi pada akhir
proses.
30
33
Step 1 − Set MIN to location 0
Step 2 − Search the minimum element in the list
Step 3 − Swap with value at location MIN
Step 4 − Increment MIN to point to next element
Step 5 − Repeat until list is sorted
SELECTION SORT: ALGORITMA

• Pilih elemen dengan nilai terendah

• Tukarkan elemen terpilih dengan
elemen pada posisi ke - i
– i dimulai dari 1 hingga n
– Dimana n adalah total elemen yang ada
dikurangi 1

35
SELECTION SORT

int i,j;
int n;

for (j = 0; j < n­1; j++) 
  {
    int iMin = j;
    for ( i = j+1; i < n; i++) {
        if (a[i] < a[iMin]) {
            iMin = i;
        }
    }
    if(iMin != j) 
    {
        swap(a[j], a[iMin]);
    }
}
MERGE SORT
• Merge sort merupakan algoritma
pengurutan dalam ilmu komputer yang
dirancang untuk memenuhi kebutuhan
pengurutan atas suatu rangkaian data
yang tidak memungkinkan untuk
ditampung dalam memori komputer
karena jumlahnya yang terlalu besar.
• Algoritma ini ditemukan oleh John von
Neumann pada tahun 1945.

37
ALGORITMA MERGE SORT
• Prinsip utama yang diimplementasikan
pada algoritma merge-sort seringkali
disebut sebagai pecah-belah dan
taklukkan (bahasa Inggris: divide and
conquer).
• Cara kerja algoritma merge sort adalah
membagi larik data yang diberikan
menjadi dua bagian yang lebih kecil.
Kedua larik yang baru tersebut
kemudian akan diurutkan secara
terpisah.
38
ALGORITMA MERGE SORT
• Setelah kedua buah list tersusun,
maka akan dibentuk larik baru sebagai
hasil penggabungan dari dua buah
larik sebelumnya.

39
CONTOH PENERAPAN
• Data sumber yang akan diurutkan {3, 9, 4, 1, 5, 2}
adalah sebagai berikut:
• Larik tersebut dibagi menjadi dua bagian, {3, 9, 4}
dan {1, 5, 2}
• Kedua larik kemudian diurutkan secara terpisah
sehingga menjadi {3, 4, 9} dan {1, 2, 5}
• Sebuah larik baru dibentuk yang sebagai
penggabungan dari kedua larik tersebut {1},
sementara nilai-nilai dalam masing larik {3, 4, 9}
dan {2, 5} (nilai 1 dalam elemen larik ke dua telah
dipindahkan ke larik baru)
40
• langkah berikutnya adalah
penggabungan dari masing-masing
larik ke dalam larik baru yang dibuat
sebelumnya.
– {1, 2} <-> {3, 4, 9} dan {5}
– {1, 2, 3} <-> {4, 9} dan {5}
– {1, 2, 3, 4} <-> {9} dan {5}
– {1, 2, 3, 4, 5} <-> {9} dan {null}
– {1, 2, 3, 4, 5, 9} <-> {null} dan {null}
41
procedure mergesort( var a as array ) procedure merge( var a as array, var b as array )
   if ( n == 1 ) return a    var c as array
   while ( a and b have elements )
   var l1 as array = a[0] ... a[n/2]
      if ( a[0] > b[0] )
   var l2 as array = a[n/2+1] ... a[n]
         add b[0] to the end of c
   l1 = mergesort( l1 )          remove b[0] from b
   l2 = mergesort( l2 )       else
   return merge( l1, l2 )          add a[0] to the end of c
end procedure          remove a[0] from a
      end if
   end while
   while ( a has elements )
      add a[0] to the end of c
      remove a[0] from a
   end while
   while ( b has elements )
      add b[0] to the end of c
      remove b[0] from b
   end while
   return c
end procedure
QUICK SORT
• Metode quick sort adalah metode
pengurutan yang menggunakan partisi.
• Pada metode ini, data dibagi menjadi
dua bagian, yaitu data disebelah kiri
partisi selalu lebih kecil dari data
disebelah kanan.
• Proses pengurutan dilakukan pada
kedua partisi secara terpisah.

46
ALGORITMA QUICKSORT
1. Tentukan unsur partisi yang diperlukan
(gunakan data tengah sebagai unsur
partisi).
2. Partisi data dalam dua bagian yang
dipisahkan oleh unsur partisi.
3. Secara rekursif sort terhadap kedua
bagian data diatas dengan dengan
metode partisi (ulangi langkah 1 dan 2
untuk data sebelah kiri dan kanan).
47
CONTOH
• Diberikan data berikut :
44 - 55 - 12 - 42 - 94 - 6 - 18 - 67
• Unsur partisi yang digunakan adalah
42 yang merupakan data tengah pada
deretan data tersebut. Dengan
menggunakan prosedur partisi urutan
data menjadi:
18 - 6 - 12 - 42 - 94 - 55 - 44 - 67
48
• Data 18, 6, 12 lebih kecil dari 42 dan
data 94, 55, 44, 67 lebih besar dari 42.
• Data kiri: 18 6 12
• Data kanan: 42 94 55 44 67
• Untuk data kiri dilakukan partisi lagi,
unsur partisinya adalah 6.
• Sub data kiri: tidak ada karena tidak
ada data yang lebih kecil dari 6
49
• Sub data kanan: 6 12 18
• Untuk sub data kanan dilakukan
partisi lagi, unsur partisinya adalah 12.
• Sub data kiri: 6
• Sub data kanan: 12 18
• Proses rekursif selesai dan data telah
terurut.

50
• Proses partisi untuk data kanan.
• Data di sebelah kanan dipartisi lagi,
dengan unsur partisinya adalah 55.
• Sub data kiri: 44 42
• Sub data kanan: 55 94 67
• Untuk sub data kiri dilakukan partisi lagi,
dengan unsur partisinya adalah 44.
• Sub data kiri: 42
• Sub data kanan: 44
51
• Untuk sub data kanan dilakukan partisi lagi, dengan
unsur partisinya adalah 94.
• Sub data kiri: 67 55
• Sub data kanan: 94
• Selanjutnya, dilakukan partisi lagi, dengan unsur
partisinya adalah 67.
• Sub data kiri: 55
• Sub data kanan: 67
• Proses rekursif untuk tabel kanan selesai.
• Data setelah pengurutan menjadi:
6 12 18 42 44 55 67 94
52
 Divide step: l scans the sequence from the left, and r from the right.

A swap is performed when l is at an element larger than the pivot and r is at one
smaller than the pivot.
A final swap with the pivot completes the divide step
quicksort(A, lo, hi) is partition(A, lo, hi) is

    if lo < hi then     pivot := A[lo]
    i := lo ­ 1
        p := partition(A, lo, hi)
    j := hi + 1
        quicksort(A, lo, p)
    loop forever
        quicksort(A, p + 1, hi)         do
            i := i + 1
        while A[i] < pivot
        do
            j := j ­ 1
        while A[j] > pivot
        if i >= j then
            return j
        swap A[i] with A[j]