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.

jika ada. Hutan[sunting | sunting sumber] Sebuah hutan adalah sebuah himpunan yang terdiri dari pohon terurut. yang dapat dikatakan memberikan sebuah simpul yang tidak memiliki susunan untuk anak dari simpul tersebut. Simpul apapun dalam pohon P. . 3. lewati preorder hutan yang dibentuk oleh sub pohon yang pertama dalam hutan. Sub pohon yang terhubung dengan simpul lain manapun dinamakan sub pohon asli (proper subtree) Penyusunan pohon Terdapat dua jenis pohon. jika ada 2. kunjungi akar dari pohon pertama.Sub pohon (Subtrees) Sebuah sub pohon adalah suatu bagian dari pohon struktur data yang dapat dilihat sebagai sebuah pohon lain yang berdiri sendiri. kunjungi akar dari pohon pertama. jika ada. jika ada 3. Sebuah pohon tidak terurut (unordered tree) adalah sebuah pohon dalam arti struktural semata-mata. Sebuah pohon dengan suatu susunan ditentukan. lewati inorder hutan yang dibentuk oleh sisa pohon dalam hutan. dan postorder didefinisikan secara rekursif untuk hutan. 2. dinamakan sebuah pohon terurut (ordered tree). lewati postorder hutan yang dibentuk oleh sisa pohon dalam hutan. lewati preorder hutan yang dibentuk oleh sisa pohon dalam hutan. kunjungi akar dari pohon pertama.  preorder 1. membentuk sebuah sub pohon dari P. preorder. lewati inorder hutan yang dibentuk oleh sub pohon yang pertama dalam hutan. Sub pohon yang terhubung dengan akar merupakan keseluruhan pohon tersebut. dan struktur data yang dibangun di dalamnya dinamakan pohon terurut struktur data(ordered tree data structures). Pohon biner terurut merupakan suatu jenis dari pohon terurut. sebagai contoh dengan mengisi bilangan asli berbeda ke setiap anak dari simpul tersebut.  postorder 1. lewati postorder hutan yang dibentuk oleh sub pohon yang pertama dalam hutan. 3. bersama dengan seluruh simpul dibawahnya. Sejauh ini pohon terurut merupakan bentuk umum dari pohon struktur data.  inorder 1. Lintasan inorder. jika ada 2. jika ada.

ayahnya. dengan hubungan diantaranya ditentukan oleh posisi mereka dalam array (contoh binary heap) Pohon sebagai grafik Dalam teori grafik. pada umumnya penggambaran mewakili simpul sebagai rekor yang dialokasikan pada heap (bedakan dengan heap struktur data) yang mengacu pada anaknya. dengan arti dari hubungan antara orang tua dan anak. dan tindakannya adalah sebuah jalan dari pohon. atau seperti data materi dalam array. sebuah pohon adalah sebuah grafik asiklis yang terhubung. sebuah penelusuran dimana anaknya dikunjungi sebelum ayahnya masing-masing dinamakan post-order walk. The Art of Computer Programming: Fundamental Algorithms. Section 2.Penggambaran pohon Ada banyak cara untuk menggambarkan pohon.3: Trees. Sebuah penelusuran dimana setiap simpul ayah dikunjungi sebelum anaknya dinamakan pre-order walk. Edisi Ketiga. . ISBN 0-201-89683-4 . 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. 1997. Seringkali. Addison-Wesley. Pohon yang berakar merupakan sebuah grafik dengan sudut tunggal di luar sebagai akar. sebuah operasi mungkin dapat dilakukan sebagai penunjuk ysng mengacu pada simpul khusus. Dalam kasus ini. atau keduanya. hal. dinamakan menelusuri pohon. 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.308–423. dua sudut apapun yang terhubung dengan sebuah sisi mewarisi hubungan orang tua dan anak.

Section 10. node *child. node *tail. }.253–320.. //================== Function ================== void Insert(). // Print All Node with Tree Interface .org/wiki/Pohon_(struktur_data)) Ini source codenya.wikipedia. node *parent. Augmenting Data Structures). Rivest.h" #include <conio. using namespace std. MIT Press and McGraw-Hill. int parentVar.h> #include <Windows. Introduction to Algorithms. node *head. int level. dan Clifford Stein. Edisi Kedua.h> #include <stdio. typedef struct node node. Chapters 12–14 (Binary Search Trees. int banyak_data = 0. // Insert Node BST + Linked List //void InsertAVL().. Red-Black Trees. int max_level = 0. Ronald L. char leftDir = 'l'. hal. Sumber: (http://id.214–217. char rightDir = 'r'. 2001. // Insert Node AVL + Linked List void Print(). node *right. node *next. node *left. Leiserson. hal. Cormen.  Thomas H.h> #include <iostream> #include <stdlib. // Standart Variable int AVL_Stat = 0.4: Representing rooted trees. node *root..h> struct node{ int data. int data_avail = 0. #include "stdafx. Charles E. node *prev. char centerDir = 'c'. ISBN 0-262-03293-7. char direction.

// Function Search data and show parent and level void Min_Max(). if (AVL_Stat == 1){ cout << "AVL Status : ON\n". // Function Show the Value Max and Min void searchInOrder(node *tWalker. // Delete AVL + Linked List void Setting().void PrintLS(). switch (pilihan){ . // Function to Search maximum level void preOrder(node *tWalker). cout << "Press 'q' to Exit\n". cout << "6. // Print All Node with Linked List Interface //void Delete(). cout << "2. Setting\n". cout << "7. // Setting about turn ON/OFF AVL Insertion //void ConvertAVL(). Print Linked List Version\n". cout << "3. do{ system("cls"). Show Min & Max \n". cout << "Input Here : ". cout << "5. // Function inOrder Tree Print void postOrder(node *tWalker). Search Data\n". cout << "================= Main Menu =================\n". Insert\n". // Convert BST --> AVL with Rebuilding Tree void getMaxLVL(). } cout << "1. } if (AVL_Stat == 0){ cout << "AVL Status : OFF\n". int input). // Delete BST + Linked List //void DeleteAVL(). // Function postOrder Tree Print void search(). cout << "=============================================\ n". cin >> pilihan. cout << "=============================================\ n". // Function Search Data Using In-Order void main(){ char pilihan. cout << "4. Print Tree Version\n". Delete\n". // Function preOrder Tree Print void inOrder(node *tWalker). cout << "Banyak data : " << banyak_data << "\n".

temp->left = NULL. if (head == NULL || root == NULL){ // Input Linked List head = temp. case '2': /*if(AVL_Stat == 1){ DeleteAVL(). . cout << "Silahkan Input data baru : ". temp = (node *)malloc(sizeof(node)). tWalker = root. case '1': /*if(AVL_Stat == 1){ InsertAVL(). case '6': Min_Max(). case '4': PrintLS(). case '7': Setting(). root = temp. break. tail = temp. Silahkan Masukkan sekali lagi!\n". default: cout << "Input Yang anda masukkan salah!. } void Insert(){ node *tWalker. int input. break. } break. case '3': Print(). int level = 1. temp->data = input. break. break. case 'q': break. system("pause"). head->next = NULL. } } while (pilihan != 'q'). case '5': search(). node *temp. head->prev = NULL. }*/ //if(AVL_Stat == 0){ Delete(). // Input BST Tree temp->level = level. node *pTemp = NULL. temp->direction = centerDir. } else{ // Input Linked List tail->next = temp. cin >> input. break. break. } break. // Because ROOT doesnt have any direction (center anyway :D) temp->right = NULL. }*/ if (AVL_Stat == 0){ Insert().

level = level + 1. // Input BST Tree level = 1. tWalker = tWalker->left. tail->next = NULL. temp->parentVar = pTemp->data. // Searching NULL Node and ready to input new node while (tWalker != NULL){ if (temp->data > tWalker->data){ pTemp = tWalker. pTemp->right = temp. temp->direction = rightDir. break. } else{ if (temp->data < pTemp->data){ temp->level = level. tWalker = tWalker->right. } else{ if (temp->data < tWalker->data){ pTemp = tWalker. . } else{ if (temp->data == tWalker->data){ pTemp = tWalker. temp->parentVar = pTemp->data. pTemp->child = temp. temp->parent = pTemp. temp->right = NULL. } } } } // Magic Start Here! :3 if (temp->data > pTemp->data){ temp->level = level. temp->parent = pTemp. temp->direction = leftDir. temp->left = NULL. tail = temp. level = level + 1.temp->prev = tail.

node *tWalker. } else{ if (temp->data == pTemp->data){ temp->level = pTemp->level. pTemp->left = temp. int levl = 1. temp->left = NULL. pTemp->child = temp. temp->direction = pTemp->direction. node *ParTemp = NULL. pTemp->left = temp->left. if (head != NULL){ // ========================== Print Based on Level ========================== while (1){ if (levl == 1){ cout << "Level 1 : [" << tWalker->data << "] Merupakan Root dari Tree\n". } } } } banyak_data = banyak_data + 1. getMaxLVL(). tWalker = root. levl = levl + 1. pWalker = head. pTemp->child = temp->child. } else{ if (levl > max_level){ break. while (1){ if (pWalker->level == levl && pWalker->direction == rightDir){ cout << "[" << pWalker->data << "(" << pWalker->parentVar << ")] ". } void Print(){ node *pWalker. } cout << "Level " << levl << " : \n". temp->right = NULL. pTemp->right = temp->right. temp->parentVar = pTemp->parentVar. . temp->parent = pTemp->parent. cout << "Right : [n(p)] ".

while (1){ if (pWalker->level == levl && pWalker->direction == leftDir){ cout << "[" << pWalker->data << "(" << pWalker->parentVar << ")] ". if (head != NULL){ while (1){ if (pWalker == root){ cout << "Data ke-" << a << ". } pWalker = pWalker->next. Post-Order. postOrder(root). if (pWalker == NULL){ cout << "\n". bernilai : " << pWalker->data << " merupakan Root dari Tree (" << pWalker->direction << ")\n". cout << "\n". pWalker = head. } else { . } } // ========================== Print Based on Level ========================== // ============== Print Based on Pre-Order. preOrder(root). and In- Order ============== cout << "\nPre-Order : ". cout << "\n". } cout << "\n\nNote : \nn = Node / Data\np = Parent\n". } } cout << "Left : [n(p)] ". int a = 0. cout << "In-Order : ". } pWalker = pWalker->next. system("pause"). inOrder(root). // ============== Print Based on Pre-Order. if (pWalker == NULL){ cout << "\n". and In- Order ============== } else{ cout << "Data Masih Kosong\n". pWalker = head. pWalker = head. cout << "\n". } } levl = levl + 1. break. break. Post-Order. cout << "Post-Order: ". } void PrintLS(){ node *pWalker.

} } cout << "\n". cout << "================== Setting ==================\n". cout << "Press 'q' for back to Main Menu\n". char confirm. Turn ON/OFF AVL Insertion\n". // int input. //} void Setting(){ char pilihan. // cout << "Silahkan masukkan data yang ingin dihapus!". cout << "=============================================\ n". a = a + 1. } system("pause"). bernilai : " << pWalker->data << " mempunyai parent : " << pWalker->parentVar << " (" << pWalker- >direction << ")\n". } //void Delete(){ // node *tWalker. } if (AVL_Stat == 0){ cout << "AVL Status : OFF\n". } pWalker = pWalker->next. if (AVL_Stat == 1){ cout << "AVL Status : ON\n". cin >> input. cout << "Data ke-" << a << ". } else{ cout << "Data Masih Kosong\n". if (pWalker == NULL){ break. do{ system("cls"). } cout << "1. .

if (pWalker == NULL){ break. Lanjutkan. Lanjutkan?\n". cout << "1. if (confirm == 1){ AVL_Stat = 1. cin >> pilihan. cout << "Input Here : ". } } while (pilihan != 'q'). cout << "Pilihan : ". } void getMaxLVL(){ node *pWalker. cout << "=============================================\ n". } break. break. max_level = pWalker->level. pWalker = head. //ConvertAVL(). Jangan lanjutkan. while (1){ if (pWalker->level >= max_level){ max_level = pWalker->level. system("pause"). } } else{ AVL_Stat = 1. dan membangun Tree ulang\n". Silahkan Masukkan sekali lagi!\n". cin >> confirm. } } if (AVL_Stat == 1){ AVL_Stat = 0. cout << "2. } pWalker = pWalker->next. switch (pilihan){ case '1': if (AVL_Stat == 0){ if (banyak_data >= 1){ cout << "Mengaktifkan AVL Insertion akan membangun kembali Tree!. default: cout << "Input Yang anda masukkan salah!. break. biarkan berbentuk BST\n". break. } } } void preOrder(node *tWalker){ if (tWalker != NULL){ . case 'q': break.

cout << tWalker->data << " ". node *tWalker = root. } cout << tWalker->data << " ". } if (tWalker->right) { preOrder(tWalker->right). Parent : " << tWalker->parentVar << ". if (tWalker->right) { inOrder(tWalker->right). cin >> input. } if (tWalker->right) { searchInOrder(tWalker->right. } } else return. cout << "\n". if (data_avail == 0){ cout << "Data yang anda cari tidak ada!\n". searchInOrder(root. if (tWalker->left) { preOrder(tWalker->left). int input){ if (tWalker != NULL){ if (tWalker->data == input){ cout << "Nilai : " << tWalker->data << ". input). } else return. } void searchInOrder(node *tWalker. } if (tWalker->left) { searchInOrder(tWalker->left. data_avail = 1. } system("pause"). cout << "Masukkan data yang ingin dicari : ". } void postOrder(node *tWalker){ if (tWalker != NULL){ if (tWalker->left) { postOrder(tWalker->left). Level : " << tWalker->level << "\n". } } else return. } } else return. } . input). } void inOrder(node *tWalker){ if (tWalker != NULL){ if (tWalker->left) { inOrder(tWalker->left). } cout << tWalker->data << " ". } if (tWalker->right) { postOrder(tWalker->right). input). } void search(){ int input.

void Min_Max(){ node *tWalker. } cout << "Nilai Maksimal : " << tWalker->data << "\n". while (tWalker->left != NULL){ tWalker = tWalker->left. tWalker = root. } cout << "Nilai Minimal : " << tWalker->data << "\n". tWalker = root. } . while (tWalker->right != NULL){ tWalker = tWalker->right. system("pause").