Tugas 2 DAA - Algoritma Sorting

8/16/2019 Tugas 2 DAA - Algoritma Sorting

http://slidepdf.com/reader/full/tugas-2-daa-algoritma-sorting 1/20

1. DESKRIPSI MASALAH

Permasalahan pengurutan data (sorting) pada dasarnya adalah suatu metode yang

digunakan untuk mengurutkan data yang acak sehingga dapat tertata secara urut dengan

aturan tertentu. 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.

Data yang diurutkan sangat bervariasi, dalam hal jumlah data maupun jenis data

yang akan diurutkan. Tidak ada algoritma terbaik untuk setiap situasi yang kita hadapi,

bahkan cukup sulit untuk menentukan algoritma mana yang paling baik untuk situasi

tertentu karena ada beberapa aktor yang mempengaruhi eektiitas algoritma pengurutan.

!eberapa aktor yang berpengaruh pada eektiitas suatu algoritma pengurutan antara

lain"• banyak data yang diurutkan

• kapasitas pengingat (memory) apakah mampu menyimpan semua data yang kita miliki

• tempat penyimpanan data, misalnya piringan, pita atau kartu, atau media penyimpan

yang lain.

Pada tugas ini kelompok kami akan membahas # buah algoritma sorting yaitu algorima

bubble sort, insertion sort, dan radi$ sort. Akan dibahas mengenai kompleksitas ketiga

algoritma berbeda tersebut sehingga akan ditemukan algoritma yang paling eekti untuk

digunakan sebagai algoritma pengurut dat.

2. ALGORITMA

A. !ubble %ort

• &ara 'erja

Diberi nama !ubble karena proses pengurutan secara berangsurangsur

bergera*berpindah ke posisi yang tepat , seperti gelembung yang keluar dari

sebuah gelas bersoda. !ubble sort mengurutkan data dengan cara

membandingkan elemen sekarang dengan elemen berikutnya. jika elemen

sekarang lebih besar dari elemen berikutnya maka elemen tersebut ditukar

(untuk pengurutan ascending) jika elemen sekarang lebih kecil daripada

elemen berikutnya, maka kedua elemen tersebut ditukar (untuk pengurutan

descending). algoritma ini seolanh olah menggeser satu per satu elemen dari

kenan ke kiri atau kiri ke kanan. tergantung jenis pengurutannya. 'etika suatu

proses telah selesai, maka bubble sort akan mengalami proses, demikian

seterusnya. !ubble sort berhenti jika seluruh array telah diperiksa dan tidak

ada pertukaran lagi yang bisa dilakukan,serta tercapai pengurutan yang telah

diinginkan

&ontoh pengurutan data yang dilakukan dengan metode bubble sort sebagai

berikut "



Proses 1 :

++ - # / +

++ - # + /

++ - + # /

++ - + # /++ - + # /

++ + - # /

+ ++ - # /

Pengecekan dimulai dari data yang paling akhir, kemudian dibandingkan

dengan data di depannya,jika data didepannya lebih besar maka akan di tukar.

Proses 2:

+ ++ - # /

+ ++ - # /

+ ++ - # /

+ ++ # - /

+ # ++ - /

pengecekan dilakukan sampai dengan data ke+ karena data pertama pasti

sudah paling kecil.

Proses 3 :

+ # ++ - /+ # ++ - /

+ # ++ / -

+ # / ++ -

Proses 4 :

+ # / ++ -

+ # / ++ -

+ # / ++ -

Proses 5 :

+ # / ++ -

+ # / - ++

Pengurutan berhenti.

• Algoritma

) 012A3

+) 0embuat array statik berisi nilai acak.

#) 0enampilkan nilai array acak berdasarkan inde$nya.



4) 0elakukan perulangan bersarang dimana perulangan pertama mengulang

sebanyak inde$ n.

) Perulangan kedua mengulang sebanyak inde$ n. dimaksudkan agar

perulangan ini mengecek nilai berulangkali sampai semua data telah di

cek.

5) Didalam perulangan diberikan pengkondisian. Apabila A%& maka nilai

inde$ ke n lebih besar dari nilai inde$ ke n6. 1ntuk D7%& berlaku

sebaliknya.

8) Apabila terjadi kondisi yang demikian maka nilai akan dilakukan

pertukaran dengan variabel bantu temporari.

/) %emua data akan dilakukan pengecekan sampai nilai semua data terurut

sesuai dengan perintah.

9) 0eampilkan semua hasil array yang telah diurutkan. .

-) %727%A3

Pseudocode ". for i: to length;A<

+. do for j:length;A< downto i6

#. do if A;j< = A;j<

4. then e$change A;j< > A; j<

!. ?adi$ %ort

• &ara kerja

?adi$ %ort merupakan salah satu algoritma @on&omparasion %ort (pengurutan

tanpa perbandingan). Proses yang dilakukan dalam metode ini adalah

mengklasiikasikan*menyelesaikan data sesuai dengan kategori terurut yang

tertentu, dan tiap kategori dilakukan pengklasiikasian lagi, dan seterusnya sesuai

kebutuhan, kemudian subkategorikategori atau bagianbagian dari kategori

tersebut digabungkan kembali.

%ecara hariah ?adi$ dapat diartikan sebagai posisi dalam angka, karena cara ini

pertama kalinya mengurutkan nilainilai yang dimasukan (input) berdasarkan

radi$ pertamanya, lalu pengurutan dilakukan berdasarkan radi$ keduanya, dan

begitu seterusnya. Pada sistem desimal, radi$ adalah digit dalam angka desimal.

0isalnya, angka 59B mempunyai # digit yaitu ,5 dan 9.

• Algoritma

Algoritma radi$ sort adalah salah satu algoritma pengurutan yang paling mangkus

karena tidak menggunakan perbandingan secara langsung. 1ntuk kasus bilangan

bulat (integer), algoritma ini akan mengurutkan data dengan mengelompokkan

datadata berdasarkan digit yang memiliki signiicant position dan value yang

sama. 'elompok digit ini ditampung dalam suatu variable bucketB. %truktur

datanya direpresentasikan dengan array. Algoritma ini pertama kali diperkenalkan

pada tahun //8 oleh Cerman Collerith pada mesin tabulasi.

Ada dua jenis radi$ sort saat ini "

2%D (least signiicant digit) radi$ sort, yaitu radi$ sort yang mengurutkan datadimulai dari digit terkecil. Algoritma ini cenderung stabil karena tetap mengikuti



urutan aal datadata sebelum diurutkan.

0%D (most signiicant digit) radi$ sort, yaitu radi$ sort yang mengurutkan data

dimulai dari digit terbesar. Algoritma ini lebih susah untuk direalisasikan daripada

2%D radi$ sort, dan biasanya tidak mengikuti urutan aal datadata yang akan

diurutkan.

0akalah ini hanya akan membahas 2%D radi$ sort.0isalkan terdapat sebuah array dengan elemen + 85 /+# #58 +#+ 4#4 84+ 9#5

+84B. Dengan menggunakan algoritma radi$ short "

Pertama kali data dibagibagi sesuai dengan digit terkanan "

+ 85 /+# #58 +#+ 4#4 84+ 9#5 +84

Pada saat penentuan kategori lihat terlebih dahulu nilai digit yang terbesar

dicontoh ini yakni nilai digit yang terbesar 9 sehingga kategori sebanyak 9 baris

dan diaali dari -. 2angsung aja supaya lebih jelas perhatikan tabel dibaah ini "

'ategori Digit (satuan) 3si

-

+

+ +#+, 84+

# /+#

4 4#4, +84

5 85, 9#5

8 #58

/

9

Casil pengkategori pertama kemudian digabungkan kembali menurut penjelasan

yang diatas"

+ +#+ 84+ /+# 4#4 +84 85 9#5 #58

'emudian dilakukan pengkategorian kembali berdasarkan digit yang kedua dengan

berpatokan(melihat) baris urutan pengkategorian pertama yaitu "


-

+ 2, /2#

# +3+, 434, 935

4 84+

5 #58

8 +74, 75

/

9

%elanjutnya hasil pengkategori kedua digabungkan kembali.?adi$ %ort



+ /+# +#+ 4#4 9#5 84+ #58 +84 85

'emudian langkah ketiga (terakhir), dilakukan pengkategorian kembali berdasar

digit ketiga. dengan berpatokan (melihat) baris urutan pengkategorian kedua

yaitu "


- 085

+

+ 2#+, 284

# #58

4 4#4

5

8 84+/ /+#

9 9#5

Eadi, hasil akhirnya dapat dituliskan "

85 + +#+ +84 #58 4#4 84+ /+# 9#5

Dari langkahlangkah yang telah dilakukan dalam proses pengurutan

menggunakan radi$ sort, jelas tampak baha radi$ sort termasuk algoritma

pengurutan tanpa pembanding. Dengan siatnya yang melihat digitdigit angka

sebagai pengontrolnya, ?adi$ %ort dapat diimplementasikan dalam pengurutan

bilangan desimal dan bilangan bit. @amun dalam penggunaannya radi$ sort bisa

dimodiikasi sehingga bisa digunakan untuk menggurutkan data data negati dan

pecahan.

Pseudocode "

k " integer

ketemu " boolean

Algoritma "

k:ketemu:alse

hile(k=Fn) and (not ketemu) do

i a$ F $ then

ketemu:true

else

k: k 6

endi

endhile

(kGn or ketemu)

i ketemu then ($ ditemukan)

id$:k else



#. %isipkan A;j< ke sekuens yang sudah disorting A;Hj<

4. i: j

. hile iG- and A;i< G key

5. do A;i6< :A;i<

8. i : i /. A;i6< :key

3. RAIA! A!ALISIS KOMPLEKSITAS ALGORITMA

A. !ubble %ort

!ubble sort menggunakan dua buah loop yakni inner loop dan outer loop. Iuter

loop akan melakukan iterasi sebanyak n kali dengan n merupakan jumlah bilangan

yang akan disorting, sedangkan inner loop digunakan untuk melakukan penelusuran

dan pertukaran nilai yang urutannya tidak benar.

. !est case analysis

'ondisi ini tercapai apabila array sudah dalam keadaan terurut. 3terasi yang bekerja

hanyalah outer loop sebanyak n kali. Perhitungannya adalah "

T (n )=∑n=0

n−1

1

%ehingga "

T (n )=n−1−0+1=n

Ileh karena itu nilai kompleksitas algoritma yang didapat adalah I(n).

+. Jorst case analysis

'ondisi ini tercapai apabila array dalam keadaan terurut namun terbalik. Ileh karena

itu dibutuhkan pengulangan sebanyak n dan pertukaran dalam inner loop. @ilai T(n)

yang didapat adalah "

T (n )=(n−1 )+(n−2 )+ (n−3 )+…+2+1

T (n )=n (n−1 )

2 =

n2−n

2

Dari persamaan tersebut dapat disimpulkan baha nilai kompleksitas algoritmanya

sebesar I(n+).

!. ?adi$ %ort

Algoritma radi$ sort membutuhkan n (nFbanyaknya bilangan yang akan disorting)

langkah untuk membentuk radi$. %elain itu, radi$ sort juga membutuhkan (n) log n

langkah untuk mengeluarkan setiap elemen dari radi$ dan menambahkannya pada

array baru. Ileh karena itu dibutuhkan total langkah sebesar "

T (n )=n+(n−1 ) log n≈n logn



&. 3nsertion %ort

3nsertion sort menggunakan sebuah kunci untuk menentukan batasan antara elemen

yang telah diurutkan dan yang belum terurut.

0isalkan b adalah baris dari algoritma insertion sort. b akan dilakukan sebanyak n

kali, b+, b4 dan b/ akan dilakukan sebanyak n kali. b# dapat diabaikan. b

dilakukan sebanyak ∑ j=2

n

t j kali. b5, dan b8 akan dilakukan sebanyak ∑ j=2

n

(t j−1) .

@ilai T(n) adalah "

t

(¿¿ j−1)+b7∑ j=2

n

(t j−1)+b8(n−1)

T (n )=b1n+b

2 (n−1 )+b

4 (n−1 )+b

5∑ j=2

n

t j+b6∑ j=2

n

¿

. !est case analysis

'ondisi ini akan tercapai apabila array yang dimiliki telah berada dalam kondisi

terurut. Dengan demikian nilai tj F . Dengan substitusi ke persamaan diatas makadidapat "

T (n )=b1n+b2 (n−1 )+b4 (n−1 )+b5 (n−1 )+b8(n−1)

Dari persamaan diatas dapat disederhanakan menjadi T(n) F an 6 b. Dengan demikian,

kompleksitas aktu asimptotiknya adalah I(n).

+. Jorst case analysis

'ondisi ini tercapai apabila array telah terurut namun dalam posisi terbalik. 7lemen

yang dijadikan kunci harus dibandingkan dengan j elemen (tj F j).

∑ j=1

n j=n (n−1 )

2,sehingga:

∑ j=2

n

j=n (n−1 )

2−1 ,sehingga :

∑ j=2

n

( j−1)=n (n−1)

2



Dengan mensubstitusikan persamaan diatas pada persamaan

t

(¿¿ j−1)+b7∑ j=2

n

( t j−1)+b8 (n−1 )

T (n )=b1n+b2 (n−1 )+b4 (n−1 )+b5∑ j=2

n

t j+b6∑ j=2

n

¿ maka diperoleh persamaan "

T (n )=b1n+b

2 (n−1 )+b

4 (n−1 )+b

5( n (n−1 )2

−1)+b6( n ( n−1 )2 )+b7( n (n−1 )

2 )+b8(n−1 )

%ehingga "

T (n )=an2+bn+c

Dari persamaan diatas dapat disimpulkan baha nilai aktu asimptotiknya adalah

I(n+

). @ilai ini juga berlaku untuk average case.

D.



.

". LISTI!G PROGRAM

2.

A. !ubble %ort3.

14.

25.

36.

47.

58.

69.

710.

811.

912.

1013.

1114.

1215.

1316.

1417.

1518.

1619.

1720.

1821.

1922.

2023.

2124.

2225.

2326.

2427.

25

28.26

38. public class Buble_Sort {

39. public static void mai!Stri"#$ ar"s% {40. && pembuata arra'41. it it(rra'#$ ) e* it#${5+ 90+ 35+ 45+ 150+

3,-42.43. S'stem.out.pritl!Buble Sort%-44. && sebelum di sorti"45. S'stem.out.pritl!Sebelum Sorti" /%-46. or !it i ) 0- i it(rra'.le"t- i% {47. S'stem.out.prit!it(rra'#i$ %-48. ,49. && proses pesorti"50. bubbleSort!it(rra'%-

51. S'stem.out.pritl!%-52.53. && setela di sorti"54. S'stem.out.pritl!Sesuda di sorti" /%-55. or !it i ) 0- i it(rra'.le"t- i% {56. S'stem.out.prit!it(rra'#i$ %-57. ,58. ,59. private static void bubbleSort!it#$ it(rra'% {60. it ) it(rra'.le"t-61. it temp ) 0-62. or !it i ) 0- i - i% {63. or !it ) 1- ! i%- % {

64. i !it(rra'# 1$ it(rra'#$% {65. temp ) it(rra'# 1$-66. it(rra'# 1$ ) it(rra'#$-67. it(rra'#$ ) temp-68. ,69. ,70. ,71. ,72. ,



29.

2730.

2831.

29

32.3033.

3134.

3235.

3336.

3437.

35

8#.7".

7#.



!. ?adi$ %ort76.

177.

278.

379.

480.

581.

682.

783.

884.

985.

1086.

1187.

1288.

1389.

1490.

1591.

1692.

1793.

1894.

1995.

2096.

2197.

2298.

2399.

24100.

25101.

26102.

27103.

128. import java.io.*;

129. import java.util.*;

130.

131. class Radix {

132.

133. static int getMax(int arr[], int n)

134. {

135. int mx = arr[0];

136. for (int i = 1; i < n; i++)

137. if (arr[i] > mx)

138. mx = arr[i];

139. return mx;

140. }

141.

142. static void countSort(int arr[], int n, int exp)

143. {

144. int output[] = new int[n]; // output array

145. int i;

146. int count[] = new int[10];

147. Arrays.fill(count,0);

148.

149. for (i = 0; i < n; i++)

150. count[ (arr[i]/exp)%10 ]++;

151.

152. for (i = 1; i < 10; i++)

153. count[i] += count[i - 1];

154.

155. // Build the output array

156. for (i = n - 1; i >= 0; i--)

157. {158. output[count[ (arr[i]/exp)%10 ] - 1] =

arr[i];

159. count[ (arr[i]/exp)%10 ]--;

160. }

161.

162. for (i = 0; i < n; i++)

163. arr[i] = output[i];

164. }

165.

166. static void radixsort(int arr[], int n)

167. {

168. // Find the maximum number to know numberof digits

169. int m = getMax(arr, n);

170.

171. for (int exp = 1; m/exp > 0; exp *= 10)

172. countSort(arr, n, exp);

173. }

174.

175. static void print(int arr[], int n)

176. {

177. for (int i=0; i<n; i++)

178. System.out.print(arr[i]+" ");

179. }

180.

181. public static void main (String[] args)



28104.

29105.

30106.

31107.

32108.

33109.

34110.

35111.

36112.

37113.

38114.

39115.

40116.

41117.

42118.

43119.

44120.

45121.

46122.

47123.

48124.

49125.

50126.

51127.

52

182. {

183. int arr[] = {170, 45, 75, 90, 802, 24, 2,

66};

184. int n = arr.length;

185. radixsort(arr, n);

186. print(arr, n);

187. }

188. }

189.

9-.

191.

&. 3nsertion %ort192.

1193.

218. public class sertioSort {

219. public static void mai!Stri" ar"s#$% {220. && pembuata arra'



2194.

3195.

4196.

5197.

6198.

7199.

8200.

9201.

10202.

11203.

12204.

13205.

14206.

15207.

16208.

17209.

18210.

19211.

20212.

21213.

22214.

23215.

24216.

25217.

26

221. it it(rra'#$ ) e* it#${5+ 90+ 35+ 45+

150+ 3,-

222. S'stem.out.pritl!sertio Sort%-

223. S'stem.out.pritl!Sebelum Sorti" /%-

224. or !it i ) 0- i it(rra'.le"t- i% {

225. S'stem.out.prit!it(rra'#i$ %-226. ,

227. && roses pe"uruta

228. or !it i ) 0- i it(rra'.le"t- i% {

229. it mi ) it(rra'#i$-

230. it ) i-

231. *ile !! 0% !mi it(rra'#

1$%% {

232. it(rra'#$ ) it(rra'# 1$-

233. -

234. ,

235. it(rra'#$ ) mi-

236. ,237. && :eceta; asil

238. S'stem.out.pritl!<Sesuda Sorti" /%-

239. or !it ) 0- it(rra'.le"t- % {

240. S'stem.out.prit!it(rra'#$ + %-

241. ,

242. ,

243. ,

+44.

+4.



#. LISTI!G HASIL2"$.

+48. Tabel Casil Perhitungan estimasi running time tiap algoritma berdasarkan kompleksitas algoritmanya+4/.

+49.

n

+-. !ubble %ort +. 3nsertion %ort ++. ?adi$ %ort

+4. !

est+. I

(n)

+5. A

verage+8. I

(n+)

+/. J

orst+9. I

(n+)

+5-. !

est+5. I

(n)

+5+. A

verage+5#. I

(n+)

+54. Jo

rst+5. I(

n+)

+55. !est

+58. I(n

log n)

+5/. Aver

age+59. I(n

log n)

+8-. Jor

st+8. I(n

log n)

+8+.

+8#. +84. +8. +85. +88. +8/. +89. - +/-. - +/. -

+/+.

++/#. + +/4. 4 +/. 4 +/5. + +/8. 4 +//. 4 +/9. -,5+ +9-. -,5+ +9. -,5+

+9+.

#+9#. # +94. 9 +9. 9 +95. # +98. 9 +9/. 9 +99. ,4# #--. ,4# #-. ,4#

#-+.

4#-#. 4

#-4.

5

#-.

5#-5. 4

#-8.

5#-/. 5 #-9. +,4 #-. +,4 #. +,4

#+.

##.

#4. +

#. +

#5.

#8. +

#/. + #9. #,49 #+-. #,49 #+. #,49

#++.

5#+#. 5

#+4. #

5

#+. #

5#+5. 5

#+8. #

5#+/. #5 #+9. 4,58 ##-. 4,58 ##. 4,58

##+.

8###. 8

##4. 4

9

##. 4

9##5. 8

##8. 4

9##/. 49 ##9. ,9+ #4-. ,9+ #4. ,9+

#4+.

/ #4#. /

#44. 5

4

#4. 5

4 #45. /

#48. 5

4 #4/. 54 #49. 8,+# #-. 8,+# #. 8,+#

#+.

9##. 9

#4. /

#. /

#5. 9

#8. /

#/. / #9. /,9 #5-. /,9 #5. /,9

#5+.

-

#5#.

-

#54.

--

#5.

--

#55.

-

#58.

--

#5/. -

-#59. - #8-. - #8. -

#8+.

+-

#8#. +

-

#84. 4

--

#8. 4

--

#85. +

-

#88. 4

--

#8/. 4-

-

#89. +5,-

+

#/-. +5,-

+

#/. +5,-

+



#/+.

#-

#/#. #

-

#/4. 9

--

#/. 9

--

#/5. #

-

#/8. 9

--

#//. 9-

-

#/9. 44,#

#9-. 44,#

#9. 44,#

#9+.

4-

#9#. 4

-

#94.

5--

#9.

5--

#95. 4

-

#98.

5--

#9/. 5

--

#99. 54,-

/

4--. 54,-

/

4-. 54,-

/

4-+.

-

4-#.

-

4-4. +

--

4-. +

--

4-5.

-

4-8. +

--

4-/. +

--

4-9. /4,9

4-. /4,9

4. /4,9

4+.

5-

4#. 5

-

44. #

5--

4. #

5--

45. 5

-

48. #

5--

4/. #5

--

49. -5,

59

4+-. -5,

59

4+. -5,

59

4++.

8-

4+#. 8

-

4+4. 4

9--

4+. 4

9--

4+5. 8

-

4+8. 4

9--

4+/. 49

--

4+9. +9,

5

4#-. +9,

5

4#. +9,

5

4#+.

/-

4##. /

-

4#4. 5

4--

4#. 5

4--

4#5. /

-

4#8. 5

4--

4#/. 54

--

4#9. +,

+

44-. +,

+

44. +,

+

44+.

9-

44#. 9

-

444. /

--

44. /

--

445. 9

-

448. /

--

44/. /

--

449. 8,

//

4-. 8,

//

4. 8,

//

4+.

--

4#.

--

44.

----

4.

----

45.

--

48.

----

4/. -

---49. +-- 45-. +-- 45. +--

45+.

--

-

45#.

---

454.

------

45.

------

455.

---

458.

------

45/. -

-----

459. #--

-

48-. #--

-48. #---



$. GRA%IK HASIL PER&A!DI!GA!

7.

a. !est &ase

/.

.- .- -.- +-.- 4-.- /-.- --.--

-

--

-

+--

+-

Kraik 7stimasi ?unning Time (!est &ase)

!ubble %ort 3nsertion %ort ?adi$ %ort

9. 'eterangan "

-. L " !anyaknya jumlah inputan. M " 7stimasi ?unning time dalam satu satuan aktu

+.

#.

b. Average &ase



4.

.- .- -.- +-.- 4-.- /-.- --.--

+---

4---

5---

/---

----

+---

Kraik 7stimasi ?unning Time (Average &ase)


. 'eterangan "

5. L " !anyaknya jumlah inputan

8. M " 7stimasi ?unning time dalam satu satuan aktu

c. Jorst &ase

/.

.- .- -.- +-.- 4-.- /-.- --.--

+---

4---

5---

/---

----

+---

Kraik 7stimasi ?unning Time (Jorst &ase)


9. 'eterangan "



+-. L " !anyaknya jumlah inputan

+. M " 7stimasi ?unning time dalam satu satuan aktu

++.



23. PEM&AHASA!

+4. !erdasarkan graik, terlihat baha untuk best case, algoritma bubble sort dan

insertion sort cocok digunakan untuk mengurutkan data dengan jumlah inputan yang

sedikit karena kompleksitas aktunya linear. %ementara penggunaan radi$sort untuk

mengurutkan data, jika data dalam best case, akan memiliki running time yang lebihrendah dari pada pengurutan data dengan menggunakan bubble dan insertion sort hanya

jika jumlah data dibaah -. Eika data yang akan diurutkan berjumlah lebih dari -, maka

running time algoritma radi$ sort menjadi jauh lebih tinggi dibanding running time

algoritma bubble sort dan insertion sort. Cal ini disebabkan radi$ sort memiliki

kompleksitas aktu n log n yang tidak sebanding dengan kompleksitas aktu linier milik

bubble dan insertion sort.

+. %edangkan untuk kasus ratarata dan kasus terburuk (average case dan orst

case), terlihat jelas baha radi$sort jauh lebih unggul dari pada insertion dan bubble sort.

Dapat dilihat dalam tabel listing hasil baha radi$ sort memiliki estimasi running time

yang jauh lebih rendah dibanding bubble sort maupun dibanding insertion sort. !ubblesort dan insertion sort masingmasing memiliki kompleksitas aktu kuadratik yang

mengakibatkan estimasi running time jauh makin membesar seiring dengan banyaknya

jumlah data yang akan disorting. %ehingga bubble sort dan insertion sort sendiri

sebenarnya tidak cocok untuk digunakan dalam pengurutan data baik itu data dalam

jumlah besar maupun data dalam jumlah kecil karena memiliki kompleksitas aktu

kuadratik, yang tidak bisa dibandingkan dengan kompleksitas aktu n log n milik radi$

sort.

+5. %ementara itu, insertion sort memiliki kompleksitas aktu yang sama persis

dengan kompleksitas aktu dari bubble sort sehingga disarankan juga tidak menggunakanalgoritma insertion sort dalam sorting data.

+8.

+/.

+9. *************************************** %tring 0atching*****************************************

30. 7. PEM&AHASA!

#. Dalam pencarian string ada dua macam yaitu mencari single pattern dan pola

pattern. Pencarian dapat di selesaikan dengan beberapa algoritma string matching

diantaranya !ruteNorce, 'nuth0orrisPratt dan !oyer0ore. 0asingmasing

algoritma mempunya kelebihan dan kelemahan tersendiri.

#+. 1ntuk pencarian single pattern algoritma 'nuth0orrisPratt lebih eekti tetapidalam pencarian pola pattern algoritma !oyer0ore lebih eekti dalam segi aktu.

!erbeda dengan algoritma !ruteNorce eekti dalam segi aktu relati tetap baik

single pattern maupun pola pattern. 7ektivitas algoritma pencarian string dapat

tergantung dari bahasa teks atau artikel yang diperlukan pencarian. Parameter seperti

panjang karakter per kata dan pengulangan karakter dalam kata dapat mempengeruhi

eektivitas algoritma pencarian string.33.

Tugas 2 DAA - Algoritma Sorting

Documents

Transcript of Tugas 2 DAA - Algoritma Sorting