Laporan Praktikum Struktur Data : Tree

Halo teman-teman semuanya selamat datang di blog saya. Perkenalkan nama saya Cahyo Adi Nugroho, saya seorang mahasiswa teknologi informasi…

Cahyoadi

~8 min read · May 10, 2026 (Updated: May 10, 2026) · Free: Yes

Halo teman-teman semuanya selamat datang di blog saya. Perkenalkan nama saya Cahyo Adi Nugroho, saya seorang mahasiswa teknologi informasi dari universitas Tidar. Pada blog ini saya akan menjelaskan laporan praktikum struktur data tentang Tree. Jadi apa itu Tree? Apa saja jenis-jenis nya? dan bagaimana penerapannya? Langsung aja simak penjelasan dibawah yaa.

TUJUAN PEMBELAJARAN

Memahami konsep dasar struktur data pohon (tree) dan terminologi penting di dalamnya.
Mengimplementasikan Binary Tree dan Binary Search Tree (BST) dalam Python.
Menerapkan operasi dasar pada pohon seperti penyisipan, traversal (preorder, inorder, postorder), dan pencarian elemen.
Mengembangkan logika program berbasis pohon untuk menyelesaikan studi kasus sederhana.

DASAR TEORI

Tree adalah tipe data non-linear yang tersusun secara hierarkis atau bertingkat. Tipe data ini memiliki pola bertingkat dimana tingkat paling atas atau utama akan melahirkan tingkat dibawahnya dan terus begitu hingga batas akhir. Tree mempunyai elemen yang disebut dengan Node, node paling atas atau utama disebut sebagai root. Root akan melahirkan node-node anakannya dan akan terus melakukan penurunan seperti silsilah keluarga. Node yang terhubung dengan node sebelumnya disebut dengan anak sedangkan yang menghubungkan anak node dengan orang tuanya (node diatasnya) disebut dengan edge.

JENIS-JENIS TREE

Walaupun sistem kerja tree dari setiap jenis sama yaitu menggunakan konsep parent-child, namun setiap memiliki keunggulan dan kekurangan masing-masing.

Binary Tree

Binary tree adalah salah satu jenis tree yang mudah dipahami, dimana setiap node maksimal memiliki dua anak yaitu anak kiri (left child) dan anak kanan (right child).

→ Kelebihan :

Memungkinkan representasi data hierarkis yang efisien.
Cocok untuk traversal rekursif dengan tiga metode utama.
Lebih hemat memori dibandingkan n-ary tree karena hanya butuh dua pointer per node.

→ Kekurangan :

Tidak menjamin efisiensi pencarian jika struktur tidak seimbang.
Tidak cocok untuk data yang perlu lebih dari dua anak per node.
Perlu penyeimbangan ulang jika ingin menjaga performa optimal dalam operasi besar.

2. Binary Search Tree (BST)

Binary Search Tree atau biasa disingkat sebagai BST adalah jenis khusus binary tree. BST memiliki konsep yang sama dengan binary tree, tetapi BST memiliki aturan yang membedakan dengan binary tree. Aturan yang membedakan binary tree dan BST adalah anak kiri (left child) harus memiliki nilai lebih kecil dari node diatasnya (parent), sedangkan anak kanan (right child) harus memiliki nilai lebih besar dari node diatasnya (parent). Dengan aturan ini akan mempermudah dalam pencarian data berdasarkan arah sehingga tidak perlu mengcek semua elemen satu per satu.

→ Kelebihan :

Operasi pencarian, penyisipan, dan penghapusan bisa dilakukan secara efisien dengan waktu rata-rata O(log n).
Struktur alami BST memungkinkan traversal inorder menghasilkan data yang terurut.
Cocok digunakan dalam aplikasi yang membutuhkan pencarian cepat dan pengurutan, seperti sistem indeks database, autocomplete, dan compiler.

→ Kekurangan :

BST tidak menjamin keseimbangan; jika data tidak merata, performanya bisa turun drastis.
Perlu tambahan algoritma balancing seperti AVL atau Red-Black Tree agar performa tetap optimal.
Penghapusan node dalam BST lebih kompleks dibanding penyisipan atau pencarian, terutama jika node memiliki dua anak.

TRAVERSAL PADA TREE

Traversal pada tree adalah proses mengcek elemen atau node dalam struktur data tree yang berbentuk hierarkis secara sistematis. Jika pada struktur data linear kita hanya perlu mengakses indeks untuk mengecek nilai suatu elemen, di struktur data non linear seperti tree kita harus melakukan penelusuran berdasarkan relasi parent-child. Tujuan traversal adalah untuk membaca, memproses, atau menampilkan isi tree sesuai urutan tertentu.

Preorder Traversal

Traversal ini dimulai dari root atau node atas lalu ke kiri lalu ke kanan. (Root → Left → Right).

2. Inorder Traversal

Metode ini sering digunakan pada BST karena algoritmanya cocok, yaitu dari left lalu ke root baru menuju right. (Left → Root → Right).

3. Postorder Traversal

Metode ini diawali dari anak kiri (left child) lalu ke anak kanan (right kanan) baru ke root. (Left → right → Root).

PRAKTIKUM

Membuat Binary Tree secara manual

print("--==Binary Tree==--")


class Node:
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

#Membuat tree secara manual
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

# Fungsi inorder traversal
def inorder(Node):
  if Node:
    inorder(Node.left)
    print(Node.data, end=' ')
    inorder(Node.right)

print("hasil inorder traversal dari binary tree :")
inorder(root)

→ Penjelasan :

Kode ini mengimplementasikan struktur data Binary Tree menggunakan kelas node yang menyimpan sebuah nilai (data) beserta pointer ke anak kiri dan kanan, yang kemudian disusun secara manual hingga membentuk hierarki dengan angka 1 sebagai akar (root). Proses penelusuran pohon dilakukan menggunakan fungsi inorder, yang menerapkan teknik rekursi dengan urutan pengecekan Kiri →Root →Kanan, sehingga program akan menyusuri cabang kiri hingga paling ujung sebelum mencetak data dan beralih ke cabang kanan.

→ Output :

2. Membuat Binary Search Tree

print("--==Binary Search Tree==--")


class Node:
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

class BinarySearchTree:
  def __init__(self):
    self.root = None

  def insert(self, root, data):
    if root is None:
      return Node(data)
    if data < root.data:
      root.left = self.insert(root.left, data)
    else:
      root.right = self.insert(root.right, data)
    return root

bst = BinarySearchTree()
root = None
data_list = (50, 30, 70, 20, 40, 60, 80)
for value in data_list:
  root = bst.insert(root, value)

→ Penjelasan :

Pada kode BST tersebut memilikikonsep di mana setiap angka dari data_list disusun ke dalam struktur hierarki berdasarkan aturan perbandingan nilai. Angka pertama (50) menjadi akar atau root. Fungsi insert akan menempatkan nilai yang lebih kecil di anak kiri dan nilai yang lebih besar di anak kanan secara rekursif. Dengan struktur ini, struktur yang terbentuk akan selalu menjaga keseimbangan logika di mana sisi kiri node berisi nilai yang lebih kecil dan sisi kanan berisi nilai yang lebih besar.

3. Traversal pada Binary Search Tree

print("--==traversal pada bst==--")
def inorder(node):
  if node:
    inorder(node.left)
    print(node.data, end=' ')
    inorder(node.right)

def preorder(node):
  if node:
    print(node.data, end=' ')
    preorder(node.left)
    preorder(node.right)

def postorder(node):
  if node:
    postorder(node.left)
    postorder(node.right)
    print(node.data, end=' ')


print("Inorder Traversal:")
inorder(root)
print("\nPreorder Traversal:")
preorder(root)
print("\nPostorder Traversal:")
postorder(root)

→ Penjelasan :

Kode ini mengimplementasikan tiga teknik Traversal Binary Search Tree yang menentukan urutan pengecekan data berdasarkan waktu kunjungan node : Inorder memproses data dengan urutan Kiri-Root-Kanan sehingga menghasilkan output yang terurut secara numerik, Preorder memproses Root-Kiri-Kanan yang sering digunakan untuk menyalin struktur pohon, sementara Postorder menggunakan urutan Kiri-Kanan-Root yang sangat efektif untuk menghapus pohon atau mengevaluasi ekspresi matematika. Ketiga fungsi ini bekerja dengan cara menyusuri setiap cabang pohon hingga mencapai node kosong, memastikan setiap elemen dikunjungi tepat satu kali sesuai dengan hierarki yang telah dibangun.

4. Pencarian Nilai dalam BST

def search(node, key):
  if node is None or node.data == key:
    return node
  if key < node.data:
    return search(node.left, key)
  return search(node.right, key)

# Uji pencarian
key = 60
result = search(root, key)
if result:
  print(f"{key} ditemukan dalam tree.")
else:
  print(f"{key} tidak ditemukan.")

key = 25
result = search(root, key)
if result:
  print(f"{key} ditemukan dalam tree.")
else:
  print(f"{key} tidak ditemukan.")

→ Penjelasan :

Fungsi pencarian ini memanfaatkan sifat utama Binary Search Tree di mana setiap node bertindak sebagai titik keputusan untuk mempersempit ruang pencarian secara efisien. Proses diawali dengan membandingkan nilai yang dicari (key) dengan data pada node saat ini, jika nilainya cocok atau node kosong, fungsi akan langsung mengembalikan hasilnya. Namun, jika nilai belum ditemukan, fungsi secara rekursif akan membelah jalur pencarian dengan hanya menelusuri cabang kiri apabila nilai yang dicari lebih kecil dari root, atau cabang kanan apabila lebih besardari root, sehingga program tidak perlu memeriksa seluruh elemen pohon satu per satu.

SOAL

Program Struktutur Binary Tree Manual

Soal 1

print("--==Soal 1 : Program Struktur Binary Tree Manual==--\n")

class Node:
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

#Membuat tree secara manual
root = Node(15)
root.left = Node(7)
root.right = Node(34)
root.left.left = Node(13)
root.left.right = Node(6)

# Fungsi inorder traversal
def inorder(Node):
  if Node:
    inorder(Node.left)
    print(Node.data, end=' ')
    inorder(Node.right)

print("hasil inorder traversal dari binary tree :")
inorder(root)

→ Ouput :

Output soal 1

2. Program Binary Search Tree (BST)

print("--==Soal 2 : Program Binary Search Tree (BST)\n")
#fungsi bst
class Node:
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

class BinarySearchTree:
  def __init__(self):
    self.root = None

  def insert(self, root, data):
    if root is None:
      return Node(data)
    if data < root.data:
      root.left = self.insert(root.left, data)
    else:
      root.right = self.insert(root.right, data)
    return root

bst = BinarySearchTree()
root = None
data_list = (34, 13, 6, 99, 97, 31, 19)
for value in data_list:
  root = bst.insert(root, value)
print(f"data : {data_list}")
print('\n')


#fungsi traversal
print("==traversal==")
def inorder(node):
  if node:
    inorder(node.left)
    print(node.data, end=' ')
    inorder(node.right)

def preorder(node):
  if node:
    print(node.data, end=' ')
    preorder(node.left)
    preorder(node.right)

def postorder(node):
  if node:
    postorder(node.left)
    postorder(node.right)
    print(node.data, end=' ')


print("Inorder Traversal:")
inorder(root)
print("\nPreorder Traversal:")
preorder(root)
print("\nPostorder Traversal:")
postorder(root)
print("\n")


#fungsi fitur pencarian
print("--==Fitur Pencarian==--")
def search(node, key):
  if node is None or node.data == key:
    return node
  if key < node.data:
    return search(node.left, key)
  return search(node.right, key)

# Uji pencarian
key = 34
result = search(root, key)
if result:
  print(f"{key} ditemukan dalam tree.")
else:
  print(f"{key} tidak ditemukan.")

key = 22
result = search(root, key)
if result:
  print(f"{key} ditemukan dalam tree.")
else:
  print(f"{key} tidak ditemukan.")print("--==Soal 2 : Program Binary Search Tree (BST)\n")
#fungsi bst
class Node:
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

class BinarySearchTree:
  def __init__(self):
    self.root = None

  def insert(self, root, data):
    if root is None:
      return Node(data)
    if data < root.data:
      root.left = self.insert(root.left, data)
    else:
      root.right = self.insert(root.right, data)
    return root

bst = BinarySearchTree()
root = None
data_list = (34, 13, 6, 99, 97, 31, 19)
for value in data_list:
  root = bst.insert(root, value)
print(f"data : {data_list}")
print('\n')


#fungsi traversal
print("==traversal==")
def inorder(node):
  if node:
    inorder(node.left)
    print(node.data, end=' ')
    inorder(node.right)

def preorder(node):
  if node:
    print(node.data, end=' ')
    preorder(node.left)
    preorder(node.right)

def postorder(node):
  if node:
    postorder(node.left)
    postorder(node.right)
    print(node.data, end=' ')


print("Inorder Traversal:")
inorder(root)
print("\nPreorder Traversal:")
preorder(root)
print("\nPostorder Traversal:")
postorder(root)
print("\n")


#fungsi fitur pencarian
print("--==Fitur Pencarian==--")
def search(node, key):
  if node is None or node.data == key:
    return node
  if key < node.data:
    return search(node.left, key)
  return search(node.right, key)

# Uji pencarian
key = 34
result = search(root, key)
if result:
  print(f"{key} ditemukan dalam tree.")
else:
  print(f"{key} tidak ditemukan.")

key = 22
result = search(root, key)
if result:
  print(f"{key} ditemukan dalam tree.")
else:
  print(f"{key} tidak ditemukan.")

→ Output :

Soal 2

KESIMPULAN

Tree adalah salah satu contoh tipe data non linear yang tersusun secara hierarkis atau bertingkat. Node paling atas atau root akan melairkan anak-anaknya dan anak-anak tersebut akan berubah menjadi node yang akan melahirkan anak mereka sendiri, Proses ini akan terus berlanjut hingga akhir. Pemilihan tipe data sangat penting untuk melahirkan sebuah sistem yang memiliki performa maksima. Tree memungkinkan kita untuk menyimpan dan mengakses informasi secara sistematis berdasarkan hubungan antar elemen, bukan sekadar urutan linier.

Penulis : Cahyo Adi Nugroho, Mahasiswa S1 Teknologi Informasi,Fakultas Teknik, Universitas Tidar Magelang

Referensi : Praktikum Struktur Data 2024/2025 — TREE

#data-structures #data-science #data #information-technology #data-analysis

< Go to the original

Laporan Praktikum Struktur Data : Tree

Halo teman-teman semuanya selamat datang di blog saya. Perkenalkan nama saya Cahyo Adi Nugroho, saya seorang mahasiswa teknologi informasi…

Reporting a Problem