MAKALAH

Desain Dan Analisa Algoritma

Disusun Untuk Memenuhi Tugas Kuliah

Mata Kuliah: Desain Dan Analisa Algoritma

Dosen Pengampu:
PANJI RACHMAT SETIAWAN, Skom.,MMSI

Disusun oleh:
NAMA : norman anak ampun
NPM : 213510010
KELAS : 4E

PROGRAM STUDI TEKNIK INFORMATIKA

UNIVERSTIAS ISLAM RIAU
T.A 2022/2023
 DAFTAR ISI
Bab I Pendahuluan
1.1 Latar belakang..............................................................................................
1.2 Rumusan masalah.........................................................................................

Bab II Pembahasan
2.1 Sorting............................................................................................................
A. Bubble Sort.....................................................................................................
B. Quick Sort......................................................................................................
C. Merge Sort......................................................................................................

2.2 Search..............................................................................................................
A. Binary Search..................................................................................................
B. Linear Search...................................................................................................
2.3 Struktur Data...................................................................................................
A. Array...............................................................................................................
B. Linked List......................................................................................................
C. Queue Tree......................................................................................................
D. Graph...............................................................................................................

Bab III Penutup

Kesimpulan............................................................................................................
Daftarpustaka ........................................................................................................

BAB I
PENDAHULUAN
1.1 Latar belakang
pentingnya memahami cara merancang dan menganalisis algoritma
yang efisien dan efektif. Seiring dengan perkembangan teknologi dan
kebutuhan komputasi yang semakin kompleks, kemampuan untuk
merancang dan menerapkan algoritma yang efektif menjadi semakin penting.
Algoritma adalah urutan instruksi logis yang digunakan untuk menyelesaikan
masalah atau tugas komputasi. Ketika merancang algoritma, penting untuk
mempertimbangkan waktu dan ruang yang diperlukan untuk menyelesaikan
tugas, serta kompleksitas algoritma dalam hal waktu dan memori. Analisis
algoritma juga memungkinkan kita untuk memahami batasan algoritma dan
memberikan dasar untuk perbandingan kinerja algoritma yang berbeda.
Oleh karena itu, mempelajari desain dan analisis algoritma sangat penting
dalam bidang ilmu komputer dan teknologi informasi. Kemampuan untuk
merancang dan menerapkan algoritma yang efisien dapat meningkatkan
kinerja sistem komputer dan mengoptimalkan penggunaan sumber daya.
Selain itu, penggunaan algoritma yang efektif juga dapat meningkatkan
efisiensi dalam berbagai bidang, seperti optimasi lalu lintas, pengolahan citra,
dan keamanan informasi.
Dalam dunia akademik, desain dan analisis algoritma adalah topik yang
sering diajarkan di berbagai program studi terkait ilmu komputer dan
teknologi informasi. Selain itu, topik ini juga menjadi subjek penelitian aktif
dalam bidang ilmu komputer dan teknologi informasi. Oleh karena itu,
pemahaman yang baik tentang desain dan analisis algoritma dapat
memberikan manfaat yang signifikan dalam berbagai bidang akademik dan
industri.
1.2 Rumusan Masalah
1. Karakter masing - masing algoritma
2. Pseudocode
3. Implementasi (kodingan) disesuaikan dengan permasalahan
4. Kompleksitas waktu
5. Berapa kemungkinan waktu yang dibutuhkan dengan menggunakan
algoritma
6. di atas.
7. Pada kompleksitas waktu, yang diperhatikan adalah waktu terburuk

BAB II
PEMBAHASAN

2.1 Sorting

A. Bubble Sort
Bubble Sort adalah algoritma pengurutan sederhana yang bekerja dengan
membandingkan pasangan-pasangan elemen dalam array secara berurutan,
kemudian menukar posisi jika elemen di sebelah kiri lebih besar dari elemen
di sebelah kanan. Algoritma ini akan terus mengulang proses ini hingga
seluruh elemen dalam array terurut dengan benar.
Pseudocode:
for i = 0 to n-1 do:

for j = 0 to n-i-1 do:

if A[j] > A[j+1] then:

swap(A[j], A[j+1])

Implementasi: Misalkan terdapat array angka berikut:

A = [4, 2, 7, 1, 3]

Setelah diurutkan menggunakan Bubble Sort, array tersebut akan menjadi:

A = [1, 2, 3, 4, 7]

Kompleksitas Waktu: Bubble Sort memiliki kompleksitas waktu O(n^2) pada

kasus terbaik, rata-rata, dan terburuk. Hal ini disebabkan oleh adanya dua
kali nested loop.
B. Quick Sort
Quick Sort adalah algoritma pengurutan yang menggunakan pendekatan
divide and conquer. Algoritma ini memilih sebuah elemen pivot dari array,
kemudian mempartisi array ke dalam dua bagian, satu dengan elemen yang
lebih kecil dari pivot dan satu lagi dengan elemen yang lebih besar dari pivot.
Setelah itu, algoritma ini memanggil dirinya sendiri secara rekursif pada
kedua bagian array tersebut hingga seluruh array terurut.

Pseudocode:

function quicksort(A, low, high):

if low < high then:

pivot_index = partition(A, low, high)

quicksort(A, low, pivot_index - 1)

quicksort(A, pivot_index + 1, high)

function partition(A, low, high):

pivot = A[high]

i = low - 1

for j = low to high - 1 do:

if A[j] <= pivot then:

i++

swap(A[i], A[j])

swap(A[i+1], A[high])

return i+1

Implementasi: Misalkan terdapat array angka berikut:

cssCopy code
A = [4, 2, 7, 1, 3]

Setelah diurutkan menggunakan Quick Sort, array tersebut akan menjadi:

A = [1, 2, 3, 4, 7]

Kompleksitas Waktu: Quick Sort memiliki kompleksitas waktu O(n log n) pada
kasus rata-rata dan terbaik, tetapi dapat mencapai
C. Merge Sort
Merge Sort adalah algoritma pengurutan yang efisien dengan cara membagi
list menjadi dua bagian yang sama besar, mengurutkan kedua bagian secara
terpisah, dan kemudian menggabungkan kembali kedua bagian tersebut
secara berurutan.

Pseudocode:
def merge_sort(list):

if len(list) <= 1:

return list

mid = len(list) // 2

left_half = list[:mid]

right_half = list[mid:]

left_half = merge_sort(left_half)
 right_half = merge_sort(right_half)

return merge(left_half, right_half)

def merge(left_half, right_half):

result = []

i=0

j=0

while i < len(left_half) and j < len(right_half):

if left_half[i] < right_half[j]:

result.append(left_half[i])

i += 1

else:

result.append(right_half[j])

j += 1

result += left_half[i:]

result += right_half[j:]

return result

Contoh implementasi penggunaan Merge Sort:

def merge_sort(list):

if len(list) <= 1:

return list

mid = len(list) // 2

left_half = list[:mid]

right_half = list[mid:]

left_half = merge_sort(left_half)

right_half = merge_sort(right_half)

return merge(left_half, right_half)

def merge(left_half, right_half):

 result = []

i=0

j=0

while i < len(left_half) and j < len(right_half):

if left_half[i] < right_half[j]:

result.append(left_half[i])

i += 1

else:

result.append(right_half[j])

j += 1

result += left_half[i:]

result += right_half[j:]

return result

unsorted_list = [64, 34, 25, 12, 22, 11, 90]

sorted_list = merge_sort(unsorted_list

Kompleksitas waktu: Kompleksitas waktu Merge Sort adalah O(n log n) pada
kasus terburuk, rata-rata, dan terbaik. Waktu yang dibutuhkan untuk
menyelesaikan pengurutan tergantung pada ukuran list yang diurutkan.
Namun, algoritma Merge Sort tetap efisien dan cepat bahkan pada list
dengan ukuran yang sangat besar.
Pada kompleksitas waktu, yang diperhatikan adalah waktu terburuk.
2.2 Search
A. Binary Search
Karakter masing-masing algoritma: Binary Search adalah algoritma pencarian
elemen di dalam list atau array yang telah diurutkan dengan membagi list
menjadi dua bagian dan memeriksa apakah elemen yang dicari ada di
setengah kiri atau setengah kanan. Proses dilakukan terus menerus hingga
elemen yang dicari ditemukan atau list dibagi hingga tidak bisa dibagi lagi.
Pseudocode:
binary_search(list, value):

low = 0
 high = len(list) - 1

while low <= high:

mid = (low + high) // 2

if list[mid] == value:

return mid

elif list[mid] < value:

low = mid + 1

else:

high = mid - 1

return -1

Contoh implementasi penggunaan Binary Search:

def binary_search(list, value):

low = 0

high = len(list) - 1

while low <= high:

mid = (low + high) // 2

if list[mid] == value:

return mid

elif list[mid] < value:

low = mid + 1

else:

high = mid - 1

return -1

sorted_list = [2, 5, 7, 12, 18, 21, 25, 30, 35]

index = binary_search(sorted_list, 21)

print(index) # output:

B. linear Search
Karakter masing-masing algoritma: Linear Search adalah algoritma pencarian
elemen di dalam list atau array secara berurutan dari elemen pertama hingga
elemen terakhir.
Pseudocode:
linear_search(list, value):

for i in range(len(list)):

if list[i] == value:

return i

return -1

Contoh implementasi penggunaan Linear Search:

def linear_search(list, value):

for i in range(len(list)):

if list[i] == value:

return i

return -1

my_list = [5, 3, 9, 8, 12, 7, 2, 1]

index = linear_search(my_list, 9)

print(index) # output: 2

Kompleksitas waktu: Kompleksitas waktu Binary Search adalah O(log n) pada

kasus terburuk, rata-rata, dan terbaik karena setiap iterasi mengurangi jumlah
elemen yang harus dicari sebanyak separuh. Sedangkan kompleksitas waktu
Linear Search adalah O(n) pada kasus terburuk, rata-rata, dan terbaik karena
setiap elemen dalam list harus diperiksa satu per satu.Pada kompleksitas
waktu, yang diperhatikan adalah waktu terburuk.
2.3 Struktur data
A. Array
Karakteristik:
• Memiliki ukuran tetap (fixed size)
• Memiliki elemen-elemen yang saling berdekatan secara kontigu dalam
memori
• Akses elemen menggunakan indeks
• Operasi pada array meliputi pencarian, pengurutan, dan manipulasi
elemen
Pseudocode:
initialize array A with size n

for i from 0 to n-1

A[i] = i+1

Implementasi:

n=5

A = [0] * n

for i in range(n):

A[i] = i+1

print(A)

Kompleksitas waktu:
• Akses elemen: O(1)
• Menambah elemen di akhir array: O(1)
• Menambah elemen di awal array: O(n)
• Menghapus elemen di akhir array: O(1)
• Menghapus elemen di awal array: O(n)
• Pencarian: O(n)
• Pengurutan: O(nlogn) atau O(n^2)

B. Linked List
Karakteristik:
• Memiliki elemen-elemen yang terpisah dalam memori
• Tiap elemen terdiri dari data dan pointer yang menunjuk ke elemen
selanjutnya
• Akses elemen menggunakan traversal dari awal hingga elemen yang
diinginkan
• Operasi pada linked list meliputi pencarian, penambahan,
penghapusan, dan manipulasi elemen
Pseudocode:
create class Node:

initialize self.data and self.next with None

class LinkedList:

initialize self.head with None

initialize self.size with 0

create method add(data) to add node to end of list:

create new_node with data

if self.head is None:

self.head = new_node

else:

current_node = self.head

while current_node.next is not None:

current_node = current_node.next

current_node.next = new_node

self.size += 1

create method remove(data) to remove node from list:

if self.head is None:

return

if self.head.data == data:

self.head = self.head.next

self.size -= 1

return

current_node = self.head

while current_node.next is not None:

if current_node.next.data == data:

current_node.next = current_node.next.next

self.size -= 1
 return

current_node = current_node.next

create method traverse() to print all nodes in list:

current_node = self.head

while current_node is not None:

print(current_node.data)

current_node = current_node.next

Implementasi:

class Node:

def __init__(self, data=None):

self.data = data

self.next = None

class LinkedList:

def __init__(self):

self.head = None

self.size = 0

def add(self, data):

new_node = Node(data)

if self.head is None:

self.head = new_node

else:

current_node = self.head

while current_node.next is not None:

current_node = current_node.next

Kompleksitas waktu pada Linked List dapat bervariasi tergantung pada

operasi yang dilakukan. Berikut adalah kompleksitas waktu pada
beberapa operasi umum pada Linked List:
• Penambahan node di awal Linked List (insertFirst): O(1)
 • Penambahan node di akhir Linked List (insertLast): O(n)
• Penambahan node di tengah Linked List (insertAfter): O(n)
• Penghapusan node di awal Linked List (deleteFirst): O(1)
• Penghapusan node di akhir Linked List (deleteLast): O(n)
• Penghapusan node di tengah Linked List (deleteAfter): O(n)
• Pencarian node dengan nilai tertentu (search): O(n)
• Traversal Linked List (menelusuri seluruh node): O(n)
Perlu diperhatikan bahwa kompleksitas waktu tersebut adalah waktu
terburuk yang dibutuhkan untuk melakukan operasi pada Linked List.
Kompleksitas waktu terbaik dapat terjadi pada beberapa kasus, seperti
pada operasi insertFirst dan deleteFirst yang memiliki kompleksitas waktu
terbaik O(1) ketika Linked List kosong.
C. Queue Tree
Karakteristik: Queue Tree adalah struktur data berbentuk pohon dimana
setiap node dapat memiliki beberapa anak, dan digunakan untuk
melakukan penelusuran level-by-level pada sebuah pohon.
Pseudocode:

queueTree(root):

queue.enqueue(root)

while not queue.isEmpty():

node = queue.dequeue()

process(node)

for child in node.children:

queue.enqueue(child)

Implementasi:
class TreeNode:

def __init__(self, val=0, children=None):

self.val = val

self.children = children if children is not None else []

 def levelOrderTraversal(root: TreeNode):

if not root:

return []

queue = [root]

result = []

while queue:

level = []

for _ in range(len(queue)):

node = queue.pop(0)

level.append(node.val)

for child in node.children:

queue.append(child)

result.append(level)

return result
Kompleksitas waktu:
Waktu terbaik: O(1) (ketika hanya terdapat 1 node)
Waktu terburuk: O(n) (ketika semua node di dalam pohon harus diproses)

D. Graph
Karakteristik: Graph adalah struktur data yang terdiri dari kumpulan simpul
(node) yang dihubungkan oleh garis (edge), digunakan untuk
merepresentasikan relasi antar objek.
Pseudocode:
DFS(node):

process(node)

visited.add(node)

for neighbor in node.neighbors:

if neighbor not in visited:

DFS(neighbor)
BFS(node):

queue.enqueue(node)

visited.add(node)

while not queue.isEmpty():

node = queue.dequeue()

process(node)

for neighbor in node.neighbors:

if neighbor not in visited:

visited.add(neighbor)

queue.enqueue(neighbor)

Implementasi:
from collections import defaultdict

class Graph:

def __init__(self):

self.graph = defaultdict(list)

def addEdge(self, u, v):

self.graph[u].append(v)

def DFS(self, node):

visited = set()

self.DFS_helper(node, visited)

def DFS_helper(self, node, visited):

visited.add(node)

print(node, end=' ')

for neighbor in self.graph[node]:

if neighbor not in visited:

 self.DFS_helper(neighbor, visited)

def BFS(self, node):

visited = set()

queue = [node]

visited.add(node)

while queue:

node = queue.pop(0)

print(node, end=' ')

for neighbor in self.graph[node]:

if neighbor not in visited:

visited.add(neighbor)

queue.append(neighbor)

Kompleksitas waktu:
Waktu terbaik: O(1) (ketika tidak terdapat edge)
Waktu terburuk: O(V + E) (V adalah jumlah node, E adalah jumlah edge)
BAB III
PENUTUP
Kesimpulan :
Dari semua topik yang telah dibahas, dapat disimpulkan bahwa dalam ilmu
komputer terdapat banyak jenis algoritma, struktur data, dan teknik
pemrograman yang berbeda untuk menyelesaikan berbagai masalah. Setiap
algoritma atau struktur data memiliki kelebihan dan kelemahan masing-
masing, serta kompleksitas waktu yang berbeda tergantung pada masalah
yang ingin diselesaikan.
Sebagai seorang programmer, penting untuk memahami konsep-konsep
dasar ini untuk dapat membuat solusi yang efektif dan efisien. Selain itu,
pemahaman yang baik tentang algoritma dan struktur data juga dapat
membantu dalam mempersiapkan diri dalam menghadapi pertanyaan dalam
wawancara kerja atau dalam menyelesaikan soal-soal dalam kontes
pemrograman.
//
 DAFTAR PUSTAKA
Halim, S., & Halim, F. (2013). Competitive Programming (3th ed.). Singapore.
unila.ac.id/wp-content/uploads/2018/05/Materi-Kuliah-Algoritma-dan-Struktur-
Data
darmawan.epizy.com/wp-content/uploads/2017/11/Materi-Algoritma