Pertemuan 13 & 14:

INF202: Struktur Data

POHON (TREE)

Dosen: Wayan Suparta, PhD

 Definisi
• Pohon (Tree) adalah graf tak-berarah terhubung yang
tidak mengandung sirkuit.
• Pohon termasuk struktur non linear yang didefinisikan
sebagai data yang terorganisir dari suatu item informasi
cabang yang saling terkait.
• Pohon yang dalam analisis pemecahan masalah
pengambilan keputusan :

 Pemetaan mengenai alternatif-alternatif pemecahan

masalah yang dapat diambil dari masalah tersebut.
 Pohon tersebut juga memperlihatkan faktor-faktor
kemungkinan/probabilitas yang akan mempengaruhi
alternatif-alternatif keputusan tersebut, disertai
dengan estimasi hasil akhir yang akan didapat bila
kita mengambil alternatif keputusan tersebut.
 Istilah dalam Tree
Term Definition
Node Sebuah elemen dalam sebuah tree; berisi sebuah informasi
Parent Node yang berada di atas node lain secara langsung; Q adalah
parent dari R dan S
Child Cabang langsung dari sebuah node; D dan E merupakan children
dari B
Root Node teratas yang tidak punya parent (P)
Sibling Sebuah node lain yang memiliki parent yang sama; Sibling dari
Q adalah T karena memiliki parent yang sama yaitu P
Leaf Sebuah node yang tidak memiliki children. R, S, V, W adalah
leaf (daun). Leaf biasa disebut sebagai external node,
sedangkan node selainnya disebut sebagai internal node. Q, B,
T, U adalah internal node
Level Semua node yang memiliki jarak yang sama dari root.
Plevel 1; Q,Tlevel 2; R, S, Ulevel 3; V, W level 4
Depth Jumlah level yang ada dalam tree
Complete Semua parent memiliki children yang penuh
Balanced Semua subtree memiliki depth yang sama
 Pengantar: Binary Tree
• Bentuk Pohon Berakar yang
lebih mudah dikelola dalam
komputer adalah Pohon Biner
(Binary Tree).
• Binary Tree lebih dikenal
sebagai Pohon Umum (General
Tree) yang dapat didefinisikan
sebagai kumpulan simpul yang
mungkin kosong atau
mempunyai akar dan dua
Subpohon yang saling terpisah
yang disebut dengan Subpohon
Kiri/cabang kiri (Left Subtree)
dan Subpohon Kanan/cabang
kanan (Right Subtree).
 Struktur Binary Tree
• Karakteristik Pohon Biner (Binary Tree) :
1. Setiap Simpul paling banyak hanya memiliki dua
buah anak
2. Derajat Tertinggi dari setiap Simpul adalah dua.
3. Dibedakan antara Cabang Kiri dan Cabang Kanan.
4. Dimungkinkan tidak mempunyai Simpul.
• Masing-masing simpul dalam binary tree terdiri dari tiga
bagian yaitu sebuah data dan dua buah pointer yang
dinamakan pointer kiri dan kanan.

Pointer Data Pointer

Istilah pada Pohon Biner
• Pohon biner miring (skewed tree)
Pembentukan Tree
 Pembentukan Tree
Langkah-langkah Pembentukan Binary Tree:

1. Siapkan node baru

- alokasikan memorinya
- masukkan infonya
- set pointer kiri & kanan = NULL
2. Sisipkan pada posisi yang tepat
- penelusuran  utk menentukan posisi yang tepat; info
yang nilainya lebih besar dari parent akan ditelusuri di
sebelah kanan, yang lebih kecil dari parent akan
ditelusuri di sebelah kiri
- penempatan  info yang nilainya lebih dari parent akan
ditempatkan di sebelah kanan, yang lebih kecil di sebelah
kiri
 Metode Traversal
• Salah satu operasi yang paling umum dilakukan terhadap
sebuah tree adalah kunjungan (traversing)
• Sebuah kunjungan berawal dari root, mengunjungi setiap node
dalam tree tersebut tepat hanya sekali
– Mengunjungi artinya memproses data/info yang ada pada
node yang bersangkutan
• Kunjungan bisa dilakukan dengan 3 cara:
1. Preorder (Prefix)
2. Inorder (Infix)
3. Postorder (Postfix)
• Ketiga macam kunjungan tersebut bisa dilakukan secara
rekursif dan non rekursif.
 Preorder (Prefix)
• Kunjungan preorder, juga disebut dengan depth first order,
menggunakan urutan:
 Cetak isi simpul yang dikunjungi void preorder(pohon ph)
{
 Kunjungi cabang kiri
if (ph != NULL)
 Kunjungi cabang kanan {
printf("%c ", ph->info);
P preorder(ph->kiri);
preorder(ph->kanan);
A T }
}
S U R I

PAS U T R I
 Inorder (Infix)
• Kunjungan secara inorder,
juga sering disebut dengan void inorder(pohon ph)
symmetric order, {
menggunakan urutan: if (ph != NULL)
 Kunjungi cabang kiri {
 Cetak isi simpul yang inorder(ph->kiri);
dikunjungi printf("%c", ph->info);
 Kunjungi cabang kanan inorder(ph->kanan);
}
P }

A T

S U R I SAUP RTI
 Postorder (Postfix)
• Kunjungan secara postorder void postorder(pohon ph)
menggunakan urutan: {
 Kunjungi cabang kiri if (ph != NULL)
 Kunjungi cabang kanan {
postorder(ph->kiri);
 Cetak isi simpul yang
postorder(ph->kanan);
dikunjungi
printf("%c ", ph->info);
}
P
}

A T

S U R I SUA RIT P
Contoh: Pre, In, and Post Order
 Contoh: Pre, In, and Post Order

Diketahui level:
54 40 66 20 50 59 75 57 62

Gambar pohon biner dan

telusuri Pre Order, In
Order dan Post Ordernya.
 Kasus traversal
T

E R

L S A I

Pre Order: T E L S R A I
In Order : L E S T A R I
Post Order: L S E A I R T
 Jenis traversal tree ada 3
1. Pre Order 3. Post Order
 Kunjungi simpul akar  Sub kiri
 Sub kiri Sub kanan
 Sub kanan  Kunjungi simpul akar
Contoh: Tree = (C * D) + E, maka Contoh, Tree = (C * D) + E,
Pre Order = +*CDE maka Post Order = CD*E+

2. In Order
 Sub kiri
 Kunjungi simpul akar
 Sub kanan
C D
Contoh, Tree = (C * D) + E, maka
In Order = C*D+E
 Contoh traversal
Tentukan traversal tree dari tree: [ A ^ (B - C) / (E * F) + G]

Maka:
Pre Order = /^-BCA+*EFG
In Order = B-C^A/E*F+G
Post Order = BC-A^EF*G+/

Perhatikan operator dengan

operasi terbanyak/terberat
akan sebagai ROOT.

Persamaan In Order adalah

mirip dengan traversal.
 Deklarasi Tree

Declarasi struct
typedef char typeInfo; typedef struct Node
typedef struct Node tree; //struct Node
{
struct Node
int data; //char data;
{ Node *kiri;
typeInfo info; /*jenis data*/ Node *kanan;
tree *kiri; /* cabang kiri */ Node *parent;
tree *kanan; /* cabang kanan */ };
} Node *pohon = NULL;
 Contoh 1: Program Binary Tree
//Tree_Binary //fungsi untuk menambahkan node baru
//header file void tambah (Node **root, int databaru)
#include <stdio.h> {
#include <conio.h> //jika root masih kosong
if ((*root)==NULL) {
#include <stdlib.h>
//pembuatan node baru
#include <iostream> Node *baru;
using namespace std; //alokasi memori dari node yang dibuat
baru = new Node;
//deklarasi AWAL struct sebuah tree //inisialisasi awal node yang baru dibuat
typedef struct Node baru->data=databaru;
{ baru->kiri=NULL;
int data; baru->kanan=NULL;
Node *kiri; (*root) = baru;
(*root) -> kiri = NULL;
Node *kanan;
(*root) -> kanan = NULL;
}; //jika menunjuk ke NULL artinya tidak
Node *pohon = NULL; mempunyai child
printf("Data Bertambah!"); }
 Sambungan …#1
//jika data yang akan dimasukkan //fungsi yang digunakan untuk mencetak tree
lebih kecil daripada elemen root, secara preOrder
maka akan diletakkan di node void preOrder(Node *root)
sebelah kiri. {
else if (databaru<(*root)->data) if(root!=NULL)
tambah(&(*root)->kiri, {
databaru); if(root->data!=NULL)
//jika data yang akan dimasukkan {
lebih besar daripada elemen root, printf("%d ",root->data);
maka akan diletakkan di node }
sebelah kanan preOrder(root->kiri);
else if (databaru>(*root)->data) preOrder(root->kanan);
tambah(&(*root)->kanan, }
databaru); }
//jika saat dicek data yang akan
dimasukkan memiliki nilai yang //fungsi yang digunakan untuk mencetak tree
sama dengan data pada root secara inOrder
else if (databaru==(*root)->data) void inOrder(Node *root)
printf("Data Sudah ada!"); {
} if(root!=NULL)
 Sambungan …#2
//fungsi utama
if(root!=NULL)
int main()
{
{
inOrder(root->kiri);
//deklarasikan variabel
if(root->data!=NULL)
char pil;
{
printf("%d ",root->data);
while (true)
}
{
inOrder(root->kanan);
system("cls"); //bersihkan layar
}
char data;
}
printf("\t#PROGRAM TREE Dev C++#");
printf("\n\t=================");
//fungsi yang digunakan untuk mencetak tree
printf("\nMENU");
secara postOrder
printf("\n----\n");
void postOrder(Node *root)
printf("[1] Tambah Data\n");
{
printf("[2] Lihat Pre-Order\n");
if(root!=NULL) {
printf("[3] Lihat In-Order\n");
postOrder(root->kiri);
printf("[4] Lihat Post-Order\n");
postOrder(root->kanan);
printf("[X] Keluar\n");
if(root->data!=NULL)
printf("Pilihan Anda : ");
{
scanf("%c",&pil);
printf("%d ",root->data); }
fflush(stdin); //mengosongkan buffering
}
}
 Sambungan …#3
switch(pil) //jika pil bernilai '3'
{ case '3':
//jika pil bernilai '1' printf("\nOUTPUT IN ORDER : ");
case '1': printf("\n------------------\n");
printf("\nINPUT : "); if(pohon!=NULL)
printf("\n-------"); //panggil fungsi untuk mencetak
printf("\nMasukkan data: "); data secara inOrder
scanf("%d", &data); inOrder(pohon);
//panggil fungsi untuk menambah node else
yang berisi data pada tree printf("Masih Kosong!!!");
tambah(&pohon,data); _getch();
_getch(); break; break;
//jika pil bernilai '2' //jika pil bernilai '4'
case '2': case '4':
printf("\nOUTPUT PRE ORDER : "); printf("\nOUTPUT POST ORDER: ");
printf("\n------------------\n"); printf("\n------------------\n");
if(pohon!=NULL) if(pohon!=NULL)
//panggil fungsi untuk mencetak data //panggil fungsi untuk mencetak data
secara preOrder secara postOrder
preOrder(pohon); postOrder(pohon);
else else
printf("Masih Kosong!!!"); printf("Masih Kosong!!!");
_getch(); _getch();
break; break;
 Sambungan …#4
//jika pil bernilai 'X' atau 'x' Catatan:
case 'X'|'x':
exit(0); • Entri data satu per satu.
break; • Pre Order  sesuai
}
}
dengan data yang
} dientri
• In Order  Diurutkan
dari kecil ke besar
• Post Order  susunan
output seperti distribusi
normal. Data pertama
terletak di akhir.
• Contoh data entry:
60 45 30 70 40 90 25 80

Pelajari contoh lain dalam link di bawah ini:

http://www.nblognlife.com/2014/12/binary
-search-tree-bst-tree-lanjutan.html
 Contoh 2: Program Gambar Tree
OUTPUT PROGRAM: //Diketahui Pre Order: MASTER
//header file
M
#include <stdio.h>
#include <conio.h>
A R #include <stdlib.h>
#include <iostream>
using namespace std;
S T
//Deklarasi Tree
typedef struct node
E {
char s152;
node *kiri;
node *kanan;
};
node *root=NULL;
 Sambungan …#1
//Tambah data //In Order
void Tambahdata(node **root, char void inorder(node *root)
u152) {
{
if((*root)==NULL){ if(root !=NULL) {
node *baru; inorder(root->kiri);
baru= new node; printf("%c ", root->s152);
baru->s152 = u152; inorder(root->kanan); }
baru->kiri = NULL;
baru->kanan = NULL; }
(*root)=baru; }
} //Post Order
//Pre Order void postorder(node *root)
void preorder(node *root) {
{ if(root !=NULL) {
if(root !=NULL) { postorder(root->kiri);
printf("%c ", root->s152); postorder(root->kanan);
preorder(root->kiri);
preorder(root->kanan); } printf("%c ", root->s152); }
} }
 Sambungan …#2
//Program utama
main()
{
char g152;
Tambahdata(&root,g152='M');
Tambahdata(&root->kiri,g152='A');
Tambahdata(&root->kiri->kiri,g152='S');
Tambahpang(&root->kiri->kiri->kiri, g152='T');
Tambahdata(&root->kiri->kiri->kanan,g152='E');
Tambahdata(&root->kanan,g152='R');

printf("Tampilan secara PreOrder : "); preorder(root);

printf("\nTampilan secara InOrder : "); inorder(root);
printf("\nTampilan secara PostOrder : "); postorder(root);
getch();
return 0;
}
 LATIHAN 19
A. Asumsikan anda mempunyai sejumlah dana untuk
diinvestasikan pada dua alternatif proyek, yaitu proyek A dan
B. Peluang proyek A akan memberikan keuntungan adalah
25% dengan nilai keuntungan 75 juta. Peluang proyek B
akan memberikan keuntungan adalah 45% dengan nilai
keuntungan 25 juta. Buatlah pohon keputusan untuk
membantu anda dalam mengambil keputusan.
B. Buatlah pohon biner dari barisan bilangan berikut:
1. 12, 22, 8, 19, 10, 9, 20, 4, 2, 6
2. B, C, D, E, Z, J, N, K, W, L, O, E, G
3. 7, 13, 4, 6, 5, 9, 15, 20, 60, 14, 40, 70
4. 50, 45, 55, 50, 40, 50, 60, 70, 40, 35, 30, 20, 80, 75, 85
5. P, N, L, Q, R, T, S, U, M, O, Y, Z, O
C. Tentukan traversal tree dari tree (A * B) + (C + D)
D. Tentukan traversal tree dari tree (C * F)^A + (B / D)+G
E. Dari contoh program biner di atas, buatlah program Pohon
Biner yang dapat melakukan tambah data secara serentak:
1. Memasukkan data
2. Melakukan Traverse
3. Menghitung jumlah node
F. Buatlah program untuk menampilkan node baru ke dalam
pohon dengan menggunakan prosedur preorder, inorder, dan
postorder sehingga akan didapatkan hasil :
Tampilan secara PreOrder : L A K C N I
Tampilan secara InOrder : K A N C I L
Tampilan secara PostOrder : K N I C A L