Room 14:

- Adzkia Aisyah Afrah Hardian (1706075035)

- Muhammad Indra Ramadhan (1706028695)
- Muhammad Ardivan Satrio Nugroho (1706025371)
- Stefanus Khrisna Aji Hardiyanto (1706074921)

Median of median
Deksripsi

Median-of-medians adalah salah satu algoritma selection deterministik yang berjalan

secara linear. Algoritma ini bekerja dengan membagi list menjadi sublist. dan menentukan
median yang ada pada list tersebut. Pada implementasinya, median digunakan sebagai pivot
untuk dibandingkan dengan elemen lain. Jika elemen tersebut lebih kecil dari pivot, maka
elemen tersebut diletakkan disebelah kiri pivot, dan juga sebaliknya. Algoritma ini menerapkan
rekursif dalam aplikasinya.

Algoritma ini akan mengambil sebuah list dan index, misalkan ​median_of_medians(A, i).
Langkah-langkah:
1. Bagi setiap list menjadi sublist dengan panjang 5 (jika kurang tidak masalah)
2. Sort tiap sublist dan tentukan median. Setiap sort yang dilakukan pada sublists tersebut
akan berjalan secara linear ​O(n)​.
3. Terapkan algoritma median_of_medians secara rekursif untuk menentukan median
dari semua bagian median.
4. Gunakan median sebagai pivot elemen, x. Pivot akan menjadi aproksimasi median dari
keseluruhan list dan melakukan rekursif sampai didapatkan median yang asli.
5. Lakukan pengurutan dimana elemen yang bernilai kurang dari x, maka akan berada
disebelah kiri dan sebaliknya.
 6. Misal k adalah “rank” dari x, yang artinya untuk set dari suatu S, maka x adalah nilai k
terkecil S
7. a. i = k ⇒ return x
b. i < k ⇒ rekursif dari (A[1.., k-1], i) atau sisi kiri dari pivot
c. i > k ⇒ rekursif dari (A[k+1, .., i], i-k) atau sisi kanan dari pivot

Pseudocode / Algo
Dalam algoritma ini misalkan kasus nya setiap list tidak ada duplikasi.

def median_of_medians(A, i):

#divide A into sublists of len 5

sublists = [A[j:j+5] for j in range(0, len(A), 5)]
medians = [sorted(sublist)[len(sublist)/2] for sublist in sublists]

if len(medians) <= 5:
pivot = sorted(medians)[len(medians)/2]

else:
#the pivot is the median of the medians
pivot = median_of_medians(medians, len(medians)/2)

#partitioning step
low = [j for j in A if j < pivot]
high = [j for j in A if j > pivot]

k = len(low)
if i < k:
return median_of_medians(low,i)
elif i > k:
return median_of_medians(high,i-k-1)
else: #pivot = k
return pivot

#Here are some example lists you can use to see how the algorithm works
#A = [1,2,3,4,5,1000,8,9,99]
#B = [1,2,3,4,5,6]
 #print median_of_medians(A, 0) #should be 1
#print median_of_medians(A,7) #should be 99
#print median_of_medians(B,4) #should be 5

Kompleksitas

Jika kita lihat dari algoritma tersebut, maka terlihat bahwa kompleksitasnya adalah O(n).
Suatu list dengan panjang n, akan dibagi menjadi n/5 sublists, dan setiap sublist akan mencari
median lagi sehingga bisa kita lihat bahwa n/5 menjadi n/10, namun misalkan terdapat nilai p
sebagai median, maka bisa saja pada n/10 elemen tadi 2 diantaranya ada yang lebih besar dan
lebih kecil, sehingga 3n/10 < p dan worst case yang mungkin adalah kita perlu melakukan
rekursif lagi untuk elemen i yang akan dicari sisanya yaitu 7n/10 elemen.
Sehingga
Untuk partitioning, memerlukan​ ​waktu
T(n)=T(n/5​)+O(n)

Dan secara keseluruhan dengan faktor adanya rekursi, maka overall kompleksitas nya menjadi
T(n)≤T(n/5​)+T(7/10n​)+O(n).

Lalu mengapa memilih nilai 5 sebagai partisi?

Alasan mengapa melakukan partisi dengan panjang 5 adalah untuk mengambil running time
yang cukup optimal.
● Misalkan kita ambil nilai 3 untuk panjang partisi. Maka untuk mencari nilai median, p kita
perlu melakukan pencarian sebanyak n/3 elemen yang mungkin bisa saja bisa lebih
besar atau lebih kecil, dan dari situ akan menyebabkan worst case rekursi 2/3n elemen
Sehingga rekurensi menjadi
T(n)=T(n^3)+T(2/3n)+O(n)

Jika dicek menggunakan master theorem akan didapatkan kompleksitas O(n log n).
 ● Maka, sebenarnya bentuk umum dari rekurensi adalah dalam form T(n) < T(an) + T(bn)
+ cn, jika a + b < 1, maka rekurensi akan menjadi O(n), sebaliknya a+b > 1, maka
rekurensi akan menjadi Ω(nlogn).

Referensi: ​https://brilliant.org/wiki/median-finding-algorithm/