Anda di halaman 1dari 13

Simpul (node)

Sebuah Simpul dapat mengandung sebuah nilai atau suatu kondisi atau menggambarkan sebuah
struktur data terpisah atau sebuah bagian pohon itu sendiri. Setiap simpul dalam sebuah pohon
memiliki nol atau lebih simpul anak (child nodes), yang berada dibawahnya dalam pohon (menurut
perjanjian, pohon berkembang ke bawah, tidak seperti yang dilakukannya di alam). Sebuah simpul
yang memiliki anak dinamakan simpul ayah (parent node) atau simpul leluhur (ancestor node)
atau superior. Sebuah simpul paling banyak memiliki satu ayah. Tinggi dari pohon adalah panjang
maksimal jalan ke sebuah daun dari simpul tersebut. Tinggi dari akar adalah tinggi dari pohon.
Kedalaman dari sebuah simpul adalah panjang jalan ke akarnya dari simpul tersebut.

Daun (Leaf nodes)


9, 14, 19, 67 dan 76 adalah daun.

Semua simpul yang berada pada tingkat terendah dari pohon dinamakan daun (leaf node). Sejak
mereka terletak pada tingkat paling bawah, mereka tidak memiliki anak satupun. Seringkali, daun
merupakan simpul terjauh dari akar. Dalam teori grafik, sebuah daun adalah sebuah sudut dengan
tingkat 1 selain akar (kecuali jika pohonnya hanya memiliki satu sudut; maka akarnya adalah
daunnya juga). Setiap pohon memiliki setidaknya satu daun.

Dalam pohon berdasarkan genetic programming sebuah daun (juga dibilang terminal) adalah bagian
terluar dari sebuah program pohon. Jika dibandingkan dengan fungsinya atau simpul dalam, daun
tidak memiliki argumen. Di banyak kasus dalam daun-GP input ke programnya.

Simpul dalam (Internal nodes)


Sebuah simpul dalam adalah semua simpul dari pohon yang memiliki anak dan bukan merupakan
daun. Beberapa pohon hanya menyimpan data di dalam simpul dalam, meskipun ini memengaruhi
dinamika penyimpanan data dalam pohon. Sebegai contoh, dengan daun yang kosong, seseorang
dapat menyimpan sebuah pohon kosong dengan satu daun. Bagaimanapun juga dengan daun yang
dapat menyimpan data, tidak dimungkinkan untuk menyimpan pohon kosong kecuali jika seseorang
memberikan beberapa jenis penanda data di daun yang menandakan bahwa daun tersebut
seharusnya kosong (dengan demikian pohon itu seharusnya kosong juga).

Sebaliknya, beberapa pohon hanya menyimpan data dalam daun, dan menggunakan simpul dalam
untuk menampung metadata yang lain, seperti jarak nilai dalam sub pohon yang berakar pada
simpul tersebut. Jenis pohon ini berguna untuk jarak yang meragukan.
Sub pohon (Subtrees)
Sebuah sub pohon adalah suatu bagian dari pohon struktur data yang dapat dilihat sebagai sebuah
pohon lain yang berdiri sendiri. Simpul apapun dalam pohon P, bersama dengan seluruh simpul
dibawahnya, membentuk sebuah sub pohon dari P. Sub pohon yang terhubung dengan akar
merupakan keseluruhan pohon tersebut. Sub pohon yang terhubung dengan simpul lain manapun
dinamakan sub pohon asli (proper subtree)

Penyusunan pohon
Terdapat dua jenis pohon. Sebuah pohon tidak terurut (unordered tree) adalah sebuah pohon
dalam arti struktural semata-mata, yang dapat dikatakan memberikan sebuah simpul yang tidak
memiliki susunan untuk anak dari simpul tersebut. Sebuah pohon dengan suatu susunan ditentukan,
sebagai contoh dengan mengisi bilangan asli berbeda ke setiap anak dari simpul tersebut,
dinamakan sebuah pohon terurut (ordered tree), dan struktur data yang dibangun di dalamnya
dinamakan pohon terurut struktur data(ordered tree data structures). Sejauh ini pohon terurut
merupakan bentuk umum dari pohon struktur data. Pohon biner terurut merupakan suatu jenis dari
pohon terurut.

Hutan[sunting | sunting sumber]


Sebuah hutan adalah sebuah himpunan yang terdiri dari pohon terurut. Lintasan inorder, preorder,
dan postorder didefinisikan secara rekursif untuk hutan.

inorder
1. lewati inorder hutan yang dibentuk oleh sub pohon yang pertama dalam hutan, jika
ada
2. kunjungi akar dari pohon pertama.
3. lewati inorder hutan yang dibentuk oleh sisa pohon dalam hutan, jika ada.
preorder
1. kunjungi akar dari pohon pertama.
2. lewati preorder hutan yang dibentuk oleh sub pohon yang pertama dalam hutan, jika
ada
3. lewati preorder hutan yang dibentuk oleh sisa pohon dalam hutan, jika ada.
postorder
1. lewati postorder hutan yang dibentuk oleh sub pohon yang pertama dalam hutan, jika
ada
2. lewati postorder hutan yang dibentuk oleh sisa pohon dalam hutan, jika ada.
3. kunjungi akar dari pohon pertama.
Penggambaran pohon
Ada banyak cara untuk menggambarkan pohon; pada umumnya penggambaran mewakili simpul
sebagai rekor yang dialokasikan pada heap (bedakan dengan heap struktur data) yang mengacu
pada anaknya, ayahnya, atau keduanya, atau seperti data materi dalam array, dengan hubungan
diantaranya ditentukan oleh posisi mereka dalam array (contoh binary heap)

Pohon sebagai grafik


Dalam teori grafik, sebuah pohon adalah sebuah grafik asiklis yang terhubung. Pohon yang berakar
merupakan sebuah grafik dengan sudut tunggal di luar sebagai akar. Dalam kasus ini, dua sudut
apapun yang terhubung dengan sebuah sisi mewarisi hubungan orang tua dan anak. Sebuah grafik
asiklis dengan bermacam-macam komponen yang terhubung atau himpunan dari pohon-pohon
yang berakar kadang-kadang dipanggil hutan

Metode traversal
Melangkah melalui materi dari pohon, dengan arti dari hubungan antara orang tua dan anak,
dinamakan menelusuri pohon, dan tindakannya adalah sebuah jalan dari pohon. Seringkali,
sebuah operasi mungkin dapat dilakukan sebagai penunjuk ysng mengacu pada simpul khusus.
Sebuah penelusuran dimana setiap simpul ayah dikunjungi sebelum anaknya dinamakan pre-order
walk; sebuah penelusuran dimana anaknya dikunjungi sebelum ayahnya masing-masing
dinamakan post-order walk.

Operasi umum
Menghitung seluruh materi (item)
Pencarian untuk sebuah materi
Menambahkan sebuah materi pada sebuah posisi tertentu dalam pohon
Menghapus sebuah materi
Mengeluarkan seluruh bagian dari sebuah pohon pruning
Menambahkan seluruh bagian ke sebuah pohon grafting
Menemukan akar untuk simpul apapun

Penggunaan umum
Memanipulasi data secara hierarki
Membuat informasi mudah untuk dicari
Memanipulasi data sorted lists

Referensi
Donald Knuth. The Art of Computer Programming: Fundamental Algorithms, Edisi Ketiga.
Addison-Wesley, 1997. ISBN 0-201-89683-4 . Section 2.3: Trees, hal.308423.
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, dan Clifford Stein. Introduction
to Algorithms, Edisi Kedua. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Section
10.4: Representing rooted trees, hal.214217. Chapters 1214 (Binary Search Trees, Red-Black
Trees, Augmenting Data Structures), hal.253320.
Sumber: (http://id.wikipedia.org/wiki/Pohon_(struktur_data))

Ini source codenya....

using namespace std;


#include "stdafx.h"
#include <conio.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <Windows.h>

struct node{
int data;
int level;
char direction;
int parentVar;
node *next;
node *prev;
node *right;
node *left;
node *parent;
node *child;
}; typedef struct node node;

node *root;
node *head;
node *tail;
// Standart Variable
int AVL_Stat = 0;
int banyak_data = 0;
int max_level = 0;
int data_avail = 0;
char centerDir = 'c';
char rightDir = 'r';
char leftDir = 'l';

//================== Function ==================


void Insert(); // Insert Node BST + Linked List
//void InsertAVL(); // Insert Node AVL + Linked List
void Print(); // Print All Node with Tree Interface
void PrintLS(); // Print All Node with Linked List Interface
//void Delete(); // Delete BST + Linked List
//void DeleteAVL(); // Delete AVL + Linked List
void Setting(); // Setting about turn ON/OFF AVL Insertion
//void ConvertAVL(); // Convert BST --> AVL with Rebuilding Tree
void getMaxLVL(); // Function to Search maximum level
void preOrder(node *tWalker); // Function preOrder Tree Print
void inOrder(node *tWalker); // Function inOrder Tree Print
void postOrder(node *tWalker); // Function postOrder Tree Print
void search(); // Function Search data and show parent and level
void Min_Max(); // Function Show the Value Max and Min
void searchInOrder(node *tWalker, int input); // Function Search Data Using
In-Order

void main(){
char pilihan;
do{
system("cls");
cout <<
"=============================================\
n";
cout << "================= Main Menu
=================\n";
cout << "Banyak data : " << banyak_data << "\n";
if (AVL_Stat == 1){
cout << "AVL Status : ON\n";
}
if (AVL_Stat == 0){
cout << "AVL Status : OFF\n";
}
cout << "1. Insert\n";
cout << "2. Delete\n";
cout << "3. Print Tree Version\n";
cout << "4. Print Linked List Version\n";
cout << "5. Search Data\n";
cout << "6. Show Min & Max \n";
cout << "7. Setting\n";
cout << "Press 'q' to Exit\n";
cout <<
"=============================================\
n";
cout << "Input Here : "; cin >> pilihan;

switch (pilihan){
case '1': /*if(AVL_Stat == 1){ InsertAVL(); }*/ if (AVL_Stat == 0){ Insert(); }
break;
case '2': /*if(AVL_Stat == 1){ DeleteAVL(); }*/ //if(AVL_Stat == 0){ Delete();
} break;
case '3': Print(); break;
case '4': PrintLS(); break;
case '5': search(); break;
case '6': Min_Max(); break;
case '7': Setting(); break;
case 'q': break;
default: cout << "Input Yang anda masukkan salah!, Silahkan Masukkan
sekali lagi!\n"; system("pause"); break;
}
} while (pilihan != 'q');
}

void Insert(){
node *tWalker;
tWalker = root;
node *pTemp = NULL;
node *temp;
temp = (node *)malloc(sizeof(node));
int input;
int level = 1;
cout << "Silahkan Input data baru : "; cin >> input;
temp->data = input;

if (head == NULL || root == NULL){


// Input Linked List
head = temp;
tail = temp;
head->next = NULL;
head->prev = NULL;

// Input BST Tree


temp->level = level;
temp->direction = centerDir; // Because ROOT doesnt have any direction
(center anyway :D)
temp->right = NULL;
temp->left = NULL;
root = temp;
}
else{
// Input Linked List
tail->next = temp;
temp->prev = tail;
tail = temp;
tail->next = NULL;

// Input BST Tree


level = 1;
// Searching NULL Node and ready to input new node
while (tWalker != NULL){
if (temp->data > tWalker->data){
pTemp = tWalker;
tWalker = tWalker->right;
level = level + 1;
}
else{
if (temp->data < tWalker->data){
pTemp = tWalker;
tWalker = tWalker->left;
level = level + 1;
}
else{
if (temp->data == tWalker->data){
pTemp = tWalker;
break;
}
}
}
}

// Magic Start Here! :3

if (temp->data > pTemp->data){


temp->level = level;
temp->direction = rightDir;
temp->parent = pTemp;
temp->parentVar = pTemp->data;
pTemp->child = temp;
pTemp->right = temp;
temp->right = NULL;
temp->left = NULL;
}
else{
if (temp->data < pTemp->data){
temp->level = level;
temp->direction = leftDir;
temp->parent = pTemp;
temp->parentVar = pTemp->data;
pTemp->child = temp;
pTemp->left = temp;
temp->right = NULL;
temp->left = NULL;
}
else{
if (temp->data == pTemp->data){
temp->level = pTemp->level;
temp->direction = pTemp->direction;
temp->parent = pTemp->parent;
temp->parentVar = pTemp->parentVar;
pTemp->child = temp->child;
pTemp->left = temp->left;
pTemp->right = temp->right;
}
}
}
}
banyak_data = banyak_data + 1;
}

void Print(){
node *pWalker;
node *tWalker;
node *ParTemp = NULL;
pWalker = head;
tWalker = root;
getMaxLVL();
int levl = 1;
if (head != NULL){

// ========================== Print Based on Level


==========================
while (1){
if (levl == 1){
cout << "Level 1 : [" << tWalker->data << "] Merupakan Root dari
Tree\n";
levl = levl + 1;
}
else{
if (levl > max_level){ break; }
cout << "Level " << levl << " : \n";
cout << "Right : [n(p)] ";
while (1){
if (pWalker->level == levl && pWalker->direction == rightDir){
cout << "[" << pWalker->data << "(" << pWalker->parentVar << ")] ";
}
pWalker = pWalker->next;
if (pWalker == NULL){ cout << "\n"; pWalker = head; break; }
}
cout << "Left : [n(p)] ";
while (1){
if (pWalker->level == levl && pWalker->direction == leftDir){
cout << "[" << pWalker->data << "(" << pWalker->parentVar << ")] ";
}
pWalker = pWalker->next;
if (pWalker == NULL){ cout << "\n"; pWalker = head; break; }
}
levl = levl + 1;
}
}
// ========================== Print Based on Level
==========================

// ============== Print Based on Pre-Order, Post-Order, and In-


Order ==============
cout << "\nPre-Order : "; preOrder(root); cout << "\n";
cout << "In-Order : "; inOrder(root); cout << "\n";
cout << "Post-Order: "; postOrder(root); cout << "\n";
// ============== Print Based on Pre-Order, Post-Order, and In-
Order ==============

}
else{
cout << "Data Masih Kosong\n";
}
cout << "\n\nNote : \nn = Node / Data\np = Parent\n";
system("pause");
}

void PrintLS(){
node *pWalker;
pWalker = head;
int a = 0;
if (head != NULL){
while (1){
if (pWalker == root){
cout << "Data ke-" << a << ", bernilai : " << pWalker->data << "
merupakan Root dari Tree (" << pWalker->direction << ")\n";
}
else {
cout << "Data ke-" << a << ", bernilai : " << pWalker->data << "
mempunyai parent : " << pWalker->parentVar << " (" << pWalker-
>direction << ")\n";
}
pWalker = pWalker->next;
a = a + 1;
if (pWalker == NULL){
break;
}
}
cout << "\n";
}
else{
cout << "Data Masih Kosong\n";
}
system("pause");
}

//void Delete(){
// node *tWalker;
// int input;
// cout << "Silahkan masukkan data yang ingin dihapus!"; cin >> input;
//}

void Setting(){
char pilihan;
char confirm;
do{
system("cls");
cout <<
"=============================================\
n";
cout << "================== Setting
==================\n";
if (AVL_Stat == 1){
cout << "AVL Status : ON\n";
}
if (AVL_Stat == 0){
cout << "AVL Status : OFF\n";
}
cout << "1. Turn ON/OFF AVL Insertion\n";
cout << "Press 'q' for back to Main Menu\n";
cout <<
"=============================================\
n";
cout << "Input Here : "; cin >> pilihan;

switch (pilihan){
case '1':
if (AVL_Stat == 0){
if (banyak_data >= 1){
cout << "Mengaktifkan AVL Insertion akan membangun kembali Tree!,
Lanjutkan?\n";
cout << "1. Lanjutkan, dan membangun Tree ulang\n";
cout << "2. Jangan lanjutkan, biarkan berbentuk BST\n";
cout << "Pilihan : "; cin >> confirm;
if (confirm == 1){
AVL_Stat = 1;
//ConvertAVL();
break;
}
}
else{ AVL_Stat = 1; break; }
}
if (AVL_Stat == 1){ AVL_Stat = 0; } break;
case 'q': break;
default: cout << "Input Yang anda masukkan salah!, Silahkan Masukkan
sekali lagi!\n"; system("pause"); break;
}
} while (pilihan != 'q');
}

void getMaxLVL(){
node *pWalker;
pWalker = head;
max_level = pWalker->level;
while (1){
if (pWalker->level >= max_level){
max_level = pWalker->level;
}
pWalker = pWalker->next;
if (pWalker == NULL){ break; }
}

void preOrder(node *tWalker){


if (tWalker != NULL){
cout << tWalker->data << " ";
if (tWalker->left) { preOrder(tWalker->left); }
if (tWalker->right) { preOrder(tWalker->right); }
}
else return;
}

void inOrder(node *tWalker){


if (tWalker != NULL){
if (tWalker->left) { inOrder(tWalker->left); }
cout << tWalker->data << " ";
if (tWalker->right) { inOrder(tWalker->right); }
}
else return;
}

void postOrder(node *tWalker){


if (tWalker != NULL){
if (tWalker->left) { postOrder(tWalker->left); }
if (tWalker->right) { postOrder(tWalker->right); }
cout << tWalker->data << " ";
}
else return;
}

void search(){
int input;
node *tWalker = root;
cout << "Masukkan data yang ingin dicari : "; cin >> input; cout << "\n";
searchInOrder(root, input);
if (data_avail == 0){ cout << "Data yang anda cari tidak ada!\n"; }
system("pause");
}

void searchInOrder(node *tWalker, int input){


if (tWalker != NULL){
if (tWalker->data == input){ cout << "Nilai : " << tWalker->data << ",
Parent : " << tWalker->parentVar << ", Level : " << tWalker->level << "\n";
data_avail = 1; }
if (tWalker->left) { searchInOrder(tWalker->left, input); }
if (tWalker->right) { searchInOrder(tWalker->right, input); }
}
else return;
}
void Min_Max(){
node *tWalker;
tWalker = root;
while (tWalker->left != NULL){
tWalker = tWalker->left;
}
cout << "Nilai Minimal : " << tWalker->data << "\n";
tWalker = root;
while (tWalker->right != NULL){
tWalker = tWalker->right;
}
cout << "Nilai Maksimal : " << tWalker->data << "\n";
system("pause");
}