Topik
ď‚— Sorting

ď‚— Selection Sort

ď‚— Straight insertion Sort

ď‚— Merge Sort
   ď‚— Paradigma Divide-and-Conquer


ď‚— Quicksort
  ď‚— Paradigma Divide-and-Conquer
ď‚— Algoritma pengurutan adalah algoritma untuk
  meletakkan kumpulan elemen data ke dlm urutan
  tertentu, berdasarkan satu atau beberapa kunci ke dalam
  tiap-tiap elemen
• Mengatur elemen berdasar urutan tertentu

• Digunakan secara luas dalam aplikasi

• Beberapa algoritma sorting telah dibuat karena
  proses tersebut sangat mendasar dan
  sering digunakan
Memudahkan dalam pencarian & memudahkan
dalam melihat data



Contoh : Kamus, buku telepon, kartu berobat, kartu
perpustakaan, dst
ď‚— 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 tabel
   ď‚— 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
ď‚— 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
1    void selectionSort(Object array[], int startIdx,
2                       int endIdx) {
3       int min;
4       for (int i = startIdx; i < endIdx; i++) {
5          min = i;
6          for (int j = i + 1; j < endIdx; j++) {
7             if (((Comparable) array[min]).compareTo(
8                                           array[j])>0) {
9                min = j;
10            }
11         }
12         swap(array[min], array[i]);
13      }
14   }
Data di cek satu persatu mulai
 dari yang kedua sampai dengan
 yang terakhir, apabila ditemukan
 data yang lebih kecil, daripada
 data sebelumnya, maka data
 tersebut disisipkan pada posisi
 yang sesuai.
i=2,N

                        data[j+1]=x
    x=data[i]
    data[0]=x
      j=i-1



                    t
   x<data[j]


          y


data[j+1]=data[j]
     dec(j)
Merge Sort:
                       Paradigma Divide-and-Conquer

ď‚— Menggunakan rekursi dalam penyelesaiannya :
   ď‚— Permasalahan awal dipilah menjadi sub-masalah
   ď‚— Solusi atas sub-masalah menuntun menuju permasalahan utama

ď‚— 3 Langkah:
   ď‚— Divide
      ď‚—   Membagi permasalahan menjadi submasalah
   ď‚— Conquer
      ď‚—   Menyelesaikan sub-masalah secara rekursif
      ď‚—   Jika sub-masalah cukup sederhana dan kecil, selesaikan secara
          langsung
   ď‚— Combine
      ď‚—   Kombinasikan solusi dari sub-masalah yang ada, hingga mencapai
          permasalahan utama
Merge Sort: Algoritma
ď‚— Menggunakan pendekatan divide-and-conquer
  ď‚— Divide
      ď‚—   Membagi elemen data menjadi dua bagian
   ď‚— Conquer
      ď‚—   Selesaikan tiap bagian secara rekursif dengan memanggil
          method mergeSort.
   ď‚— Combine
      ď‚—   Kombinasikan dua bagian secara rekursif untuk
          mendapatkan urutan yang diharapkan

ď‚— Rekursi selesai pada saat sisa dari sebagian elemen yang akan diurutkan
  tepat tersisa satu
   ď‚— Telah terurutkan
Merge Sort: Algoritma
1    void mergeSort(Object array[], int startIdx,
2     int endIdx) {
3       if (array.length != 1) {
4       Divide the array into two halves,
5       leftArr and rightArr
6       mergeSort(leftArr, startIdx, midIdx);
7       mergeSort(rightArr, midIdx+1, endIdx);
8          combine(leftArr, rightArr);
9       }
10   }
Merge Sort: Contoh
Quicksort: Algoritma
    ď‚— Ditemukan oleh C.A.R. Hoare

    ď‚— Berdasar pada paradigma divide-and-conquer
       ď‚— Divide
          ď‚—   Bagi array menjadi dua subarray A[p...q-1] dan A[q+1...r] dimana
              A[p...q-1] adalah kurang dari atau sama dengan A[q] dan elemen
              pada A[q+1...r] adalah lebih dari atau sama dengan A[q]
          ď‚—   A[q] disebut sebagai pivot
          ď‚—   Perhitungan q adalah bagian dari prosedur pemisahan
       ď‚— Conquer
          ď‚—   Urutkan subarray tersebut dengan memanggil method quickSort
              secara rekursif
        Tak perlu melakukan proses “Combine”
          ď‚—   Subarrays telah terurutkan
Quicksort: Algoritma

1    void quickSort(Object array[], int leftIdx,
2                   int rightIdx) {
3       int pivotIdx;
4       /* Termination condition! */
5       if (rightIdx > leftIdx) {
6          pivotIdx = partition(array, leftIdx,
     rightIdx);
7          quickSort(array, leftIdx, pivotIdx-1);
8          quickSort(array, pivotIdx+1, rightIdx);
9       }
10   }
Quicksort: Contoh
Quicksort: Contoh
Kesimpulan
ď‚— Teknik Sorting sederhana
   ď‚— Insertion Sort
   ď‚— Selection Sort

ď‚— Paradigma Divide-and-Conquer
   ď‚— Merge Sort
   ď‚— Quicksort

Algoritma sorting

  • 2.
    Topik ď‚— Sorting ď‚— SelectionSort ď‚— Straight insertion Sort ď‚— Merge Sort ď‚— Paradigma Divide-and-Conquer ď‚— Quicksort ď‚— Paradigma Divide-and-Conquer
  • 3.
    ď‚— Algoritma pengurutanadalah algoritma untuk meletakkan kumpulan elemen data ke dlm urutan tertentu, berdasarkan satu atau beberapa kunci ke dalam tiap-tiap elemen
  • 4.
    • Mengatur elemenberdasar urutan tertentu • Digunakan secara luas dalam aplikasi • Beberapa algoritma sorting telah dibuat karena proses tersebut sangat mendasar dan sering digunakan
  • 5.
    Memudahkan dalam pencarian& memudahkan dalam melihat data Contoh : Kamus, buku telepon, kartu berobat, kartu perpustakaan, dst
  • 6.
    ď‚— Algoritma sortingyang 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 tabel ď‚— 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
  • 7.
    ď‚— Pilih elemendengan 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
  • 8.
    1 void selectionSort(Object array[], int startIdx, 2 int endIdx) { 3 int min; 4 for (int i = startIdx; i < endIdx; i++) { 5 min = i; 6 for (int j = i + 1; j < endIdx; j++) { 7 if (((Comparable) array[min]).compareTo( 8 array[j])>0) { 9 min = j; 10 } 11 } 12 swap(array[min], array[i]); 13 } 14 }
  • 10.
    Data di ceksatu persatu mulai dari yang kedua sampai dengan yang terakhir, apabila ditemukan data yang lebih kecil, daripada data sebelumnya, maka data tersebut disisipkan pada posisi yang sesuai.
  • 11.
    i=2,N data[j+1]=x x=data[i] data[0]=x j=i-1 t x<data[j] y data[j+1]=data[j] dec(j)
  • 12.
    Merge Sort: Paradigma Divide-and-Conquer ď‚— Menggunakan rekursi dalam penyelesaiannya : ď‚— Permasalahan awal dipilah menjadi sub-masalah ď‚— Solusi atas sub-masalah menuntun menuju permasalahan utama ď‚— 3 Langkah: ď‚— Divide ď‚— Membagi permasalahan menjadi submasalah ď‚— Conquer ď‚— Menyelesaikan sub-masalah secara rekursif ď‚— Jika sub-masalah cukup sederhana dan kecil, selesaikan secara langsung ď‚— Combine ď‚— Kombinasikan solusi dari sub-masalah yang ada, hingga mencapai permasalahan utama
  • 13.
    Merge Sort: Algoritma ď‚—Menggunakan pendekatan divide-and-conquer ď‚— Divide ď‚— Membagi elemen data menjadi dua bagian ď‚— Conquer ď‚— Selesaikan tiap bagian secara rekursif dengan memanggil method mergeSort. ď‚— Combine ď‚— Kombinasikan dua bagian secara rekursif untuk mendapatkan urutan yang diharapkan ď‚— Rekursi selesai pada saat sisa dari sebagian elemen yang akan diurutkan tepat tersisa satu ď‚— Telah terurutkan
  • 14.
    Merge Sort: Algoritma 1 void mergeSort(Object array[], int startIdx, 2 int endIdx) { 3 if (array.length != 1) { 4 Divide the array into two halves, 5 leftArr and rightArr 6 mergeSort(leftArr, startIdx, midIdx); 7 mergeSort(rightArr, midIdx+1, endIdx); 8 combine(leftArr, rightArr); 9 } 10 }
  • 15.
  • 16.
    Quicksort: Algoritma  Ditemukan oleh C.A.R. Hoare  Berdasar pada paradigma divide-and-conquer  Divide  Bagi array menjadi dua subarray A[p...q-1] dan A[q+1...r] dimana A[p...q-1] adalah kurang dari atau sama dengan A[q] dan elemen pada A[q+1...r] adalah lebih dari atau sama dengan A[q]  A[q] disebut sebagai pivot  Perhitungan q adalah bagian dari prosedur pemisahan  Conquer  Urutkan subarray tersebut dengan memanggil method quickSort secara rekursif  Tak perlu melakukan proses “Combine”  Subarrays telah terurutkan
  • 17.
    Quicksort: Algoritma 1 void quickSort(Object array[], int leftIdx, 2 int rightIdx) { 3 int pivotIdx; 4 /* Termination condition! */ 5 if (rightIdx > leftIdx) { 6 pivotIdx = partition(array, leftIdx, rightIdx); 7 quickSort(array, leftIdx, pivotIdx-1); 8 quickSort(array, pivotIdx+1, rightIdx); 9 } 10 }
  • 18.
  • 19.
  • 20.
    Kesimpulan ď‚— Teknik Sortingsederhana ď‚— Insertion Sort ď‚— Selection Sort ď‚— Paradigma Divide-and-Conquer ď‚— Merge Sort ď‚— Quicksort