TUGAS RANGKUMAN

DESAIN DAN ANALISIS ALGORITMA

DIVIDE AND CONQUER

MATRIX MULTIPLICATION

Nama Kelompok :

AMELIA PUSPITA ELLA

NIM. 1810652003

FAKULTAS TEKNIK

PROGRAM STUDI TEKNIK INFORMATIKA

UNIVERSITAS MUHAMMADIYAH JEMBER

2019
 CH. 8
Decrease and Conquer:

Source : http://nadiataradhita.blogspot.com/2016/12/decrease-
and-conquer.html

Decrease and conquer adalah metode desain algoritma dengan

mereduksi persoalan menjadi beberapa sub-persoalan yang lebih
kecil, tetapi selanjutnya hanya memproses satu sub-persoalan saja.
Metode ini memiliki dua tahapan, antara lain:
- Decrease, yaitu mereduksi persoalan menjadi beberapa persoalan
yang lebih kecil (biasanya dua sub-persoalan)
- Conquer, yaitu memproses satu sub-persoalan secara rekursif.
Terdapat tiga varian pengurangan pada metode decrease and
conquer, antara lain decrease by a constant, decrease by a constant
factor, dan decrease by a variable size.

A. Insertion sort
Source : http://mydailycodes9896.blogspot.com/2018/03/struktur-
data-insertion-sort-quick-sort.html

nsertion Sort merupakan metode pengurutan data yang cara kerjanya

menyisipkan suatu elemen list pada posisi yang sesuai. Posisi
tersebut dicari dengan cara membandingkan suatu elemen dengan
elemen-elemen sebelumnya. Pada algoritma ini, mula-mula elemen
pertama dianggap telah berada pada posisi yang tepat. Selanjutnya,
elemen kedua akan dibandingkan dengan elemen pertama. Jika
elemen pertama lebih besar dari elemen kedua, maka elemen
pertama akan digeser ke kanan menjadi elemen kedua dan elemen
kedua sebelumnya akan disisiplan pada posisi pertama.

Setelah itu, elemen ketiga akan dibandingkan dengan elemen kedua

dan pertama. Jika elemen kedua lebih besar dari elemen ketiga,
maka elemen kedua akan digeser ke kanan. Selanjutnya, elemen
ketiga akan dibandingkan lagi dengan elemen pertama. Jika elemen
pertama lebih besar dari elemen ketiga, maka elemen pertama juga
akan digeser ke kanan dan elemen ketiga akan disisipkan pada
posisi pertama. Jika elemen pertama lebih kecil dari elemen ketiga,
maka elemen ketiga akan disisipkan pada posisi kedua.

Demikian seterusnya sampai seluruh elemen di dalam list terproses.

Untuk lebih mudah dalam memahami proses di dalam algoritma
Insertion sort, perhatikan implementasinya dalam Python :
 Penjelasan program
def insertionsort(alist):
print('Nilai awal: \t\t\t', end='')
print(alist)
print("")
for i in range(1, len(alist)):
value = alist[i]
print('Menyisipkan nilai %d: \t' %value, end='')
position=i
while position > 0 and alist[position-1] > value:
alist[position]=alist[position-1]
position-=1
alist[position]=value
print(alist)
a=[12,5,2,7,10]
insertionsort(a)

B. BFS (Breadth First Search)

Source : http://michaeljulius11.blogspot.com/2017/10/pengertian-
metode-pencarian-bfs-dan-dfs.html

Pengertian :
Breadth-first search adalah algoritma yang melakukan pencarian
secara melebar yang mengunjungi simpul secara preorder yaitu
mengunjungi suatu simpul kemudian mengunjungi semua simpul
yang bertetangga dengan simpul tersebut terlebih dahulu.
Selanjutnya, simpul yang belum dikunjungi dan bertetangga dengan
simpulsimpul yang tadi dikunjungi , demikian seterusnya. Jika graf
berbentuk pohon berakar, maka semua simpul pada aras d
dikunjungi lebih dahulu sebelum simpul-simpul pad aras d+1.
Algoritma ini memerlukan sebuah antrian q untuk menyimpan simpul
yang telah dikunjungi. Simpulsimpul ini diperlukan sebagai acuan
untuk mengunjungi simpul-simpul yang bertetanggaan dengannya.
Tiap simpul yang telah dikunjungu masuk ke dalam antrian hanya
satu kali. Algoritma ini juga membutuhkan table Boolean untuk
menyimpan simpul yang te lah dikunjungi sehingga tidak ada simpul
yang dikunjungi lebih dari satu kali.

CARA KERJA ALGORITMA BFS

Dalam algoritma BFS, simpul anak yang telah dikunjungi disimpan
dalam suatu antrian. Antrian ini digunakan untuk mengacu simpul-
simpul yang bertetangga dengannya yang akan dikunjungi kemudian
sesuai urutan pengantrian.
Untuk memperjelas cara kerja algoritma BFS beserta antrian yang
digunakannya, berikut langkah-langkah algoritma BFS:

- Masukkan simpul ujung (akar) ke dalam antrian.

- Ambil simpul dari awal antrian, lalu cek apakah simpul merupakan
solusi.
- Jika simpul merupakan solusi, pencarian selesai dan hasil
dikembalikan..
- Jika simpul bukan solusi, masukkan seluruh simpul yang
bertetangga dengan simpul tersebut (simpul anak) ke dalam
antrian.
- Jika antrian kosong dan setiap simpul sudah dicek, pencarian
selesai dan mengembalikan hasil solusi tidak ditemukan.
- Ulangi pencarian dari langkah kedua.

Contoh Metode Pencarian BFS (BREADTH FIRST SEARCH )

Maka penyelesaiannya adalah:

Gambar (a) BFS(1): 1, 2, 3, 4, 5, 6, 7, 1.

Gambar (b) BFS(1): 1, 2, 3, 4, 5, 6, 7, 1
Gambar (c) BFS(1): 1, 2, 3, 4, 5, 6, 7, 8, 9

# finds shortest path between 2 nodes of a graph using BFS

def bfs_shortest_path(graph, start, goal):
# keep track of explored nodes
explored = []
# keep track of all the paths to be checked
queue = [[start]]
 # return path if start is goal
if start == goal:
return "That was easy! Start = goal"

# keeps looping until all possible paths have been checked

while queue:
# pop the first path from the queue
path = queue.pop(0)
# get the last node from the path
node = path[-1]
if node not in explored:
neighbours = graph[node]
# go through all neighbour nodes, construct a new path
and
# push it into the queue
for neighbour in neighbours:
new_path = list(path)
new_path.append(neighbour)
queue.append(new_path)
# return path if neighbour is goal
if neighbour == goal:
return new_path

# mark node as explored

explored.append(node)

# in case there's no path between the 2 nodes

return "So sorry, but a connecting path doesn't exist :("
 bfs_shortest_path(graph, 'G', 'D') # returns ['G', 'C', 'A', 'B', 'D']

C. DFS (Depth First Search)

DFS (Depth-First-Search) adalah salah satu algoritma penelusuran
struktur graf / pohon berdasarkan kedalaman. Simpul ditelusuri dari
root kemudian ke salah satu simpul anaknya ( misalnya prioritas
penelusuran berdasarkan anak pertama [simpul sebelah kiri] ), maka
penelusuran dilakukan terus melalui simpul anak pertama dari simpul
anak pertama level sebelumnya hingga mencapai level terdalam.

Setelah sampai di level terdalam, penelusuran akan kembali ke 1

level sebelumnya untuk menelusuri simpul anak kedua pada pohon
biner [simpul sebelah kanan] lalu kembali ke langkah sebelumnya
dengan menelusuri simpul anak pertama lagi sampai level terdalam
dan seterusnya.

Contoh pohon biner Depth First Search :

Maka, urutan penelusurannya adalah : A – B – D – H – E – I – C – F
–G–J–K–L

Dalam implementasinya DFS dapat diselesaikan dengan cara rekursif

atau dengan bantuan struktur data stack. Kita akan membahas
dengan cara yang menggunakan stack. Stack yang digunakan adalah
stack yang isi elemennya adalah simpul pohon / tree. Bagaimana
cara kerjanya ? Berikut ini adalah urutan algoritmanya :

- Masukkan simpul root ke dalam tumpukan dengan push.

- Ambil dan simpan isi elemen (berupa simpul pohon) dari tumpukan
teratas.
- Hapus isi stack teratas dengan prosedur pop.
- Periksa apakah simpul pohon yang disimpan tadi memiliki anak
simpul.
- Jika ya, push semua anak simpul yang dibangkitkan ke dalam
stack.
- Jika tumpukan kosong berhenti, tapi jika tidak kembali ke langkah
dua.
- Jadi, untuk gambar pohon biner di atas urutan langkah dan kondisi
stack-nya setiap iterasi adalah :
Contoh diatas menggunakan prioritas untuk memasukkan anak
simpul dari sebelah kanan terlebih dahulu ke dalam stack. Sehingga,
pada iterasi 2 elemen A dihapus lalu memasukkan anak simpulnya
yaitu C dulu, baru B ke dalam stack. Selain itu bisa dilihat stack
teratas (yang diwarna biru) pada tiap iterasi memiliki urutan A – B – D
– H – E – I – C – F – G – J – K – L. Oiya, pada iterasi ke 13 itu
kondisi stack sudah kosong karena ketika simpul J dibangkitkan tidak
ada anak simpul yang dimasukkan ke stack.

Program Python
# Python3 program to print DFS traversal
# from a given given graph
from collections import defaultdict

# This class represents a directed graph using

# adjacency list representation
class Graph:

# Constructor
def __init__(self):

# default dictionary to store graph

self.graph = defaultdict(list)

# function to add an edge to graph

def addEdge(self, u, v):
self.graph[u].append(v)
 # A function used by DFS
def DFSUtil(self, v, visited):

# Mark the current node as visited

# and print it
visited[v] = True
print(v, end = ' ')

# Recur for all the vertices

# adjacent to this vertex
for i in self.graph[v]:
if visited[i] == False:
self.DFSUtil(i, visited)

# The function to do DFS traversal. It uses

# recursive DFSUtil()
def DFS(self, v):

# Mark all the vertices as not visited

visited = [False] * (len(self.graph))

# Call the recursive helper function

# to print DFS traversal
self.DFSUtil(v, visited)

# Driver code
 # Create a graph given
# in the above diagram
g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)

print("Following is DFS from (starting from vertex 2)")

g.DFS(2)

# This code is contributed by Neelam Yadav

Keluaran

D. BST (Binary Search Tree)

Source : https://www.mahirkoding.com/struktur-data-binary-search-
tree-bst/

Sebelum mengenal lebih jauh tentang Binary Search Tree, ada

baiknya kita membahas struktur data Tree terlebih dahulu. Tree
(pohon) adalah salah satu bentuk struktur data yang menggambarkan
hubungan hierarki antar elemen-elemennya (seperti relasi one to
 many). Sebuah node dalam tree biasanya bisa memiliki beberapa
node lagi sebagai percabangan atas dirinya.

Lalu, ada lagi yang namanya Binary Tree. Apa bedanya? Sebenarnya
sama sama konsepnya dengan Tree. Hanya saja, kita akan mengambil
sifat bilangan biner yang selalu bernilai 1 atau 0 (2 pilihan). Berarti,
binary tree adalah tree yang hanya dapat mempunyai maksimal 2
percabangan saja. Untuk lebih jelasnya, lihat gambar di bawah ini.

Lanjut lagi, sekarang kita akan memasuki pembelajaran intinya yaitu

Binary Search Tree atau sering disingkat BST. Apalagi BST itu? Dan
apa bedanya dengan yang dua diatas? Sebenarnya mirip-mirip saja,
Binary Search Tree adalah struktur data yang mengadopsi konsep
Binary Tree namun terdapat aturan bahwa setiap clild node sebelah kiri
selalu lebih kecil nilainya dari pada root node. Begitu pula sebaliknya,
setiap child node sebelah kanan selalu lebih besar nilainya daripada root
node.

Kenapa harus membedakan kiri dan kanan sesuai besaran nilainya?

Tujuannya untuk memberikan efisiensi terhadap proses searching.
Kalau struktur data tree sudah tersusun rapi sesuai aturan mainnya,
proses search akan lebih cepat.

Aturan main Binary Search Tree :

1. Setiap child node sebelah kiri harus lebih kecil nilainya daripada
root nodenya.
2. Setiap child node sebelah kanan harus lebih besar nilainya
daripada root nodenya.
Lalu, ada 3 jenis cara untuk melakukan penelusuran data (traversal)
pada BST :
1. PreOrder : Print data, telusur ke kiri, telusur ke kanan
2. InOrder : Telusur ke kiri, print data, telusur ke kanan
3. Post Order : Telusur ke kiri, telusur ke kanan, print data

Program
# Python program to demonstrate insert operation in binary search tree
# A utility class that represents an individual node in a BST
class Node:
def __init__(self,key):
self.left = None
self.right = None
self.val = key

# A utility function to insert a new node with the given key

def insert(root,node):
if root is None:
root = node
else:
if root.val < node.val:
if root.right is None:
root.right = node
else:
insert(root.right, node)
else:
if root.left is None:
root.left = node
else:
insert(root.left, node)

# A utility function to do inorder tree traversal

def inorder(root):
if root:
inorder(root.left)
 print(root.val)
inorder(root.right)

# Driver program to test the above functions

# Let us create the following BST
# 50
# / \
# 30 70
# /\ /\
# 20 40 60 80
r = Node(50)
insert(r,Node(30))
insert(r,Node(20))
insert(r,Node(40))
insert(r,Node(70))
insert(r,Node(60))
insert(r,Node(80))

# Print inoder traversal of the BST

inorder(r)

# This code is contributed by Bhavya Jain

Keluaran