Nama : Septiya nuraeni

NIM : 1955201019
Matkul : Algoritma dan pemograman 2
Tanggal : 27 april 2021
Tugas : Meresume materi mergesort, quicksort, dan binary seacrh,

A. Mergesort
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 pengurutan data merge sort dilakukan
dengan menggunakan cara divide and conquer yaitu dengan memecah kemudian menyelesaikan setiap
bagian kemudian menggabungkannya kembali. Pertama data dipecah menjadi 2 bagian dimana bagian
pertama merupakan setengah (jika data genap) atau setengah minus satu (jika data ganjil) dari seluruh data,
kemudian dilakukan pemecahan kembali untuk masing-masing blok sampai hanya terdiri dari satu data tiap
blok.
Setelah itu digabungkan kembali dengan membandingkan pada blok yang sama apakah data pertama
lebih besar daripada data ke-tengah+1, jika ya maka data ke-tengah+1 dipindah sebagai data pertama,
kemudian data ke-pertama sampai ke-tengah digeser menjadi data ke-dua sampai ke-tengah+1, demikian
seterusnya sampai menjadi satu blok utuh seperti awalnya. Sehingga metode merge sort merupakan metode
yang membutuhkan fungsi rekursi untuk penyelesaiannya.
Algoritma dirumuskan dalam 3 langkah berpola divide-and-conquer. Berikut menjelaskan langkah
kerja dari Merge sort.
 Divide, Memilah elemen – elemen dari rangkaian data menjadi dua bagian.
 Conquer, Conquer setiap bagian dengan memanggil prosedur merge sort secara rekursif
 Kombinasi, Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan rangkaian
data berurutan.
Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi bilamana bagian yang akan
diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu elemen tersebut menandakan bahwa bagian
tersebut telah terurut sesuai rangkaian.
Contoh Perhitungan
Angka Sebelum Diurutkan : 6 3 5 1 8 2 4 7

 Pertama kali larik tersebut dibagi menjadi dua bagian, {6, 3, 5, 1} dan {8, 2, 4, 7}
 Kedua larik kemudian diurutkan secara terpisah sehingga menjadi {6, 3}, {5, 1}, {8, 2}, dan {4, 7}
 Ketiga larik kemudian diurutkan secara terpisah sehingga menjadi {6}, {3}, {5}, {1}, {8}, {2},
{4}, dan {7}
 Sebuah larik baru dibentuk yang sebagai penggabungan dari setiap dua larik dan diurutkan,
sehingga masing-masing larik memilik nilai {3, 6}, {1, 5}, {2, 8}, dan {4, 7}
  Bentuk larik baru lagi yang merupakan penggabungan dari setiap dua larik dan diurutkan, sehingga
masing-masing lari memilik nilai {1, 3, 5, 6} dan {2, 4, 7, 8}
 Langkah berikutnya adalah penggabungan dari masing-masing larik ke dalam larik baru yang
dibuat sebelumnya, sehingga memiliki nilai {1, 2, 4, 5, 6, 7, 8}

Source Code PHP Algoritma Merge Sort

function merge_sort($my_array){
if(count($my_array) == 1 ) return $my_array;
$mid = count($my_array) / 2;
$left = array_slice($my_array, 0, $mid);
$right = array_slice($my_array, $mid);
$left = merge_sort($left);
$right = merge_sort($right);
return merge($left, $right);
}
function merge($left, $right){
$res = array();
while (count($left) > 0 && count($right) > 0){
if($left[0] > $right[0]){
$res[] = $right[0];
$right = array_slice($right , 1);
}else{
$res[] = $left[0];
$left = array_slice($left, 1);
}
}
while (count($left) > 0){
$res[] = $left[0];
$left = array_slice($left, 1);
}
while (count($right) > 0){
$res[] = $right[0];
$right = array_slice($right, 1);
}
return $res;
}

Cara Pakai

$test_array = array(100, 54, 7, 2, 5, 4, 1);

print_r(merge_sort($test_array));

B. Quicksort
 Quick Sort merupakan suatu algoritma pengurutan data yang menggunakan teknik pemecahan data
menjadi partisi-partisi, sehingga metode ini disebut juga dengan nama partition exchange sort. Untuk
memulai irterasi pengurutan, pertama-tama sebuah elemen dipilih dari data, kemudian elemen-elemen data
akan diurutkan diatur sedemikian rupa.
Algoritma ini mengambil salah satu elemen secara acak (biasanya dari tengah) yang disebut dengan
pivot lalu menyimpan semua elemen yang lebih kecil di sebelah kiri pivot dan semua elemen yang lebih
besar di sebelah kanan pivot. Hal ini dilakukan secara rekursif terhadap elemen di sebelah kiri dan
kanannya sampai semua elemen sudah terurut.
Algoritma Quick Sort.

 Pilih satu elemen secara acak sebagai pivot

 Pindahka semua elemen yang lebih kecil ke sebelah kiri pivot dan semua elemen yang lebih besar ke sebelah
kanan pivot. Elemen yang nilainya sama bisa disimpan di salah satunya.

 Lakukan sort secara rekursif terhadap sub-array sebelah kiri dan kanan pivot

Tips Pemilihan Pivot:

Dalam algoritma quick sort, pemilihan pivot adalah hal yang menentukan apakah algoritma quick sort
tersebut akan memberikan performa terbaik atau terburuk. Berikut beberapa cara pemilihan pivot :

 Pivot adalah elemen pertama, elemen terakhir, atau elemen tengah tabel. Cara ini hanya bagus jika elemen tabel
tersusun secara acak, tetapi tidak bagus jika elemen tabel semula sudah terurut. Misalnya, jika elemen tabel semula
menurun, maka semua elemen tabel akan terkumpul di upatabel kanan.

 Pivot dipilih secara acak dari salah satu elemen tabel. Cara ini baik, tetapi mahal, sebab memerlukan biaya (cost)
untuk pembangkitan prosedur acak. Lagi pula, itu tidak mengurangi kompleksitas waktu algoritma.

 Pivot adalah elemen median tabel. Cara ini paling bagus, karena hasil partisi menghasilkan dua bagian tabel yang
berukuran seimbang (masing masing ≈ n/2 elemen). Cara ini memberikan kompleksitas waktu yang minimum.
Masalahnya, mencari median dari elemen tabel yang belum terurut adalah persoalan tersendiri. Algoritma Quick
Sort terdiri dari dua prosedur, yaitu prosedur PARTISI dan prosedur QUICKSORT.

Keunggulan Quick sort:

 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
mergesort dan heapsort.

 Melakukan proses langsung pada input (in-place) dengan sedikit tambahan memori.

 Bekerja dengan baik pada berbagai jenis input data (seperti angka dan karakter).

Kekurangan Quick short:

 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.

 Pada bahasa pemrograman, quicksort ada dalam pustaka stdlib.h untuk bahasa C, dan class TList dan TStringList
dalam Delphi (Object Pascal) maupun FreePascal.

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 :

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]+" , ");
}
}
}
ini adalah hasil dari pemrogramannya

C. Binary Search
Binary Search merupakan sebuah teknik pencarian data dengan cara berulang kali membagi separuh
dari jumlah data yang dicari sampai sehingga memperkecil lokasi pencarian menjadi satu data. Dengan
teknik ini kita akanmembuang setengah dari jumlah data. Apabila ditemukan kecocokan data maka
program akan mengembalikan output, jika tidak pencarian akan terus berlanjut hingga akhir dari
pembagian jumlah data tersebut.

Algotihma ini biasanya banyak digunakan untuk mencari di program dengan jumlah data yang
banyak, dimana kompleksitas dari algorithma ini adalah Ο(log n) di mana n adalah jumlah item. Pada saat
menggunakan binary search, data yang berada di dalam array harus diurutkan terlebih dahulu.

Misalkan kita memiliki int arr[] = {70, 60, 30, 50, 40,20}, data para int arr harus diurutkan terlebih
dahulu menggunakan teknik sorting seperti bubble sort. Sehingga array kita akan menjadi int arr[] =
{20,30,40,50,60,70}. Apabila angka yang dicari adalah angka 40,

berikut gambaran dari implementasi BinarySearch:

1st Cycle:

(20,30,40,50,60,70)

LOW = 0

HIGH = N

MID = (LOW + HIGH)/2 = (0+6)/2 = 3

(arr[MID] == 40)

(20,30,40,50,60,70)

(50==40) // FALSE

HIGH = MID-1

*Array di mulai dari index ke 0, maka index ke 3 berisi nilai 50.

2nd Cycle:

(20,30,40,50,60,70)

MID = (LOW + HIGH)/2 = (0+2)/2 = 1

(arr[MID] == 40)

(20,30,40,50,60,70)

(30==40) // FALSE

LOW = MID+1

3rd Cycle:

(20,30,40,50,60,70)

MID = (LOW + HIGH)/2 = (2+2)/2=2

(arr[MID] == 40)

(20,30,40,50,60,70)

(40==40) // TRUE

Jika data ditemukan, maka program akan keluar dari looping. Jika kita ingin menampilkan index dari data
yang dicari, kita tinggal menyimpan index dari array tersebut dan menampilkan nya.

Berikut implementasi dari Binary Search menggunakan Bahasa C:

Referensi :
https://arfianhidayat.com/algoritma-merge-sort
http://onophp.blogspot.com/2018/11/quick-sort-pengertian-agoritma-dan.html?m=1
https://socs.binus.ac.id/2019/12/26/binary-search/