Modul 20 : Tree

Tujuan :
1. Mahasiswa mampu memahami tipe data tree
2. Mahasiswa mampu membuat program operasi pada queue

Peralatan Pendukung :
1. Modul Praktikum (Cetak)
2. Aplikasi Dev c++

1. Teori Dasar
Tree atau pohon merupakan struktur data yang tidak linear yang digunakan untuk mempresentasikan
data yang bersifat hirarki antara elemen-elemennya.
Definisi tree yaitu kumpulan elemen yang salah satu elemennya disebut root (akar) dan elemen yang lain
disebut simpul ( node) yang terpecah menjadi sejumlah kumpulan yang tidak saling berhubungan satu
sama lain yang disebut sub-tree atau cabang.
Tree adalah struktur data yang terdiri dari entitas yang disebut node yang terkait melaui sebuah edge.
Node paling atas disebut dengan root. Yang tergambar seperti pohon terbalik.

ISTILAH-ISTILAH DALAM TREE.

Predecessor Node yang berada di atas node tertentu
Successor Node yang berada dibawah node tertentu
Seluruh node yang terletak sebelum node tertentu dan terletak pada jalur yang
Ancestor
sama
Seluruh node yang terletak setelah node tertentu dan terletak pada jalur yang
Descendant
sama
Parent Predecessor satu level di atas suatu node
Children Successor satu level di bawah suatu node
Sibling Node-node yang memiliki parent yang sama dengan suatu node
Bagian dari tree yang berupa suatu node beserta descendantnya dan memiliki
Subtree semua
karakteristik dari tree tersebut
Size Banyaknya node dalam suatu tree
Height anyaknya tingkatan / level dalam suatu tree
Root Satu-satunya node khusus dalam tree yang tak punyak predecessor
Leaf Node-node dalam tree yang tak memiliki successor
Degree Banyaknya child yang dimiliki suatu node
Depth of Node Jumlah edge dari root ke node
Height of Node Jumlah edge terpanjang dari node ke leaf
Height of Tree Height of root node

Hal | 181
Untuk lebih memahami istilah – istilah diatas, perhatikanlah gambar-gambar dibawah ini :
Gambar 1 (Root, Parent, Children, Sibling, Leaf)

Gambar 2 (Node dan Edge)

n  node

n-1  edge

Gambar 3 (Depth of Node, Height of Node, Height of Tree)

BINARY TREE
Binary Tree adalah tree dimana setiap node mempunyai paling banyak 2 children. Children dari setiap
node disebut left-child dan right-child.

MACAM-MACAM BINARY TREE

 Complete Binary Tree
Semua level selain level terakhir pada tree terisi
lengkap dan semua node kiri terisi lebih dahulu

Hal | 182
  Perfect Binary Tree
Semua level pada tree terisi lengkap

Binary tree dibentuk dengan node yang mempunyai Data dan dua buah pointer/link ( *Left dan
*Right )

Struktur Data Tree mirip dengan Double Linked List, hanya beda penamaan.
DATA : berisi informasi setiap 1 buah elemen tree, bisa berupa bilangan (int), string, maupun
address.
LEFT : merupakan bagian elemen yang bertipe dasar “Address”, yaitu berisi alamat untuk
menunjuk tree bagian kiri.
RIGHT : merupakan bagian elemen yang bertipe dasar “Address”, yaitu berisi alamat untuk
menunjuk tree bagian kanan.

2. Praktikum
Praktikum 1 : Membuat Tree
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
using namespace std;

//Deklarasi Tree dengan Struct

struct Node {
int data;
struct Node *left, *right;
};

//Function untuk menambahkan Node di KIRi dan Kanan

Node* TambahNode(int data)
{
Node* temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
Hal | 183
 return temp;
}

/*Program Utama*/
int main(){
struct Node* root = TambahNode(1); //Isi Root Node dengan data 1
root->left = TambahNode(2); //Tambah node di kiri Root, data 2
root->right = TambahNode(3); //Tambah node di Kanan Root, data 3
root->left->left = TambahNode(4); //Tambah node di kiri Children Root, data 4
root->left->right = TambahNode(5); //Tambah node di kanan Children Root, data 5
return 0;
}

Ilutrasi output dari program diatas

2 3

4 5

Analisa Program Praktikum 1

Ubahlah data pada deklarasi Tree dari int ke char.
struct Node {
char data;
struct Node *left, *right;
};

Kemudian lakukan input data sehingga tree yang terbentuk seperti dibawah ini

Praktikum 2 : Pembacaan Data Pada Tree (Binary Tree Traversal)

Ada2 cara pembacaan data pada Tree yaitu :
1. Breadth First atau Level Order Traversal
Mengunjungi setiap node dari level teratas kemudian bergerak ke node sebelah kiri kemudian node
sebelah kanan pada level dibawahnya.

Hal | 184
2. Depth First, meliputi :
a. Preorder
Mengunjungi node terbawah hingga mencapai setiap children node dengan urutan :
Right children Left children  Parent

b. Inorder
Mengunjungi node terbawah hingga mencapai setiap children node dengan urutan:
Right children  Parent Left children

c. Postorder
Mengunjungi node terbawah hingga mencapai setiap children node dengan urutan:
Parent  Right children  Left children

Hal | 185
Program Level Order Traversal

#include <bits/stdc++.h>
using namespace std;

class node {
public:
int data;
node *left, *right;
};

void printCurrentLevel(node* root, int level);

int height(node* node);
node* newNode(int data);

/* Cetak semua level */

void printLevelOrder(node* root)
{
int h = height(root);
int i;
for (i = 1; i <= h; i++)
printCurrentLevel(root, i);
}

/* Cetak per level */

void printCurrentLevel(node* root, int level)
{
if (root == NULL)
return;
if (level == 1)
cout << root->data << " ";
else if (level > 1) {
printCurrentLevel(root->left, level - 1);
printCurrentLevel(root->right, level - 1);
}
}

/* Cari jumlah level */

int height(node* node)
{
if (node == NULL)
return 0;
else {
/* compute the height of each subtree */
int lheight = height(node->left);
int rheight = height(node->right);

/* use the larger one */

if (lheight > rheight) {
return (lheight + 1);
}
else {
return (rheight + 1);
}
}
}

/* Tambah Node */
node* newNode(int data)
{
node* Node = new node();
Node->data = data;
Hal | 186
 Node->left = NULL;
Node->right = NULL;

return (Node);
}

/* Driver code*/
int main()
{
node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);

cout << "Hasil Level Order traversal binary tree \n";

printLevelOrder(root);

return 0;
}

Program Depth First Traversal

#include <iostream>
using namespace std;

//Deklarasi Tree dengan Struct

struct Node {
char data;
struct Node *left, *right;
};

//Function untuk menambahkan Node di KIRi dan Kanan

Node* TambahNode(int data)
{
Node* temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}

void printPostorder(struct Node* node)

{
if (node == NULL)
return;

printPostorder(node->left);
printPostorder(node->right);
cout << node->data << " ";
}

void printInorder(struct Node* node)

{
if (node == NULL)
return;
printInorder(node->left);
cout << node->data << " ";
printInorder(node->right);
}

void printPreorder(struct Node* node)

{
Hal | 187
 if (node == NULL)
return;
cout << node->data << " ";
printPreorder(node->left);
printPreorder(node->right);
}

int main()
{
struct Node* root = TambahNode('H');
//Kiri
root->left = TambahNode('D');
root->left->left = TambahNode('B');
root->left->left->left = TambahNode('A');
root->left->left->right = TambahNode('C');
root->left->right = TambahNode('F');
root->left->right->left = TambahNode('E');
root->left->right->right = TambahNode('G');

//Kanan
root->right = TambahNode('K');
root->right->left = TambahNode('I');
root->right->left->right = TambahNode('J');

root->right->right = TambahNode('L');

cout << "\nHasil Preorder traversal binary tree \n";

printPreorder(root);

cout << "\nHasil Inorder traversal binary tree \n";

printInorder(root);

cout << "\nHasil Postorder traversal binary tree \n";

printPostorder(root);

return 0;
}

Analisa Program Praktikum 2

-

3. Latihan
-

4. Tugas
-

Hal | 188