Tree Pada C++ (Tree Awal)

PENGERTIAN TREE

Kumpulan node yang saling terhubung satu sama lain dalam suatu kesatuan yang membentuk layakya struktur sebuah pohon. Struktur pohon adalah suatu cara merepresentasikan suatu struktur hirarki (one-to-many) secara grafis yang mirip sebuah pohon, walaupun pohon tersebut hanya tampak sebagai kumpulan node-node dari atas ke bawah. Suatu struktur data yang tidak linier yang menggambarkan hubungan yang hirarkis (one-to-many) dan tidak linier antara elemen-elmennya.

ISTILAH DALAM TREE

Ilustrasi alogaritma tree

Keterangan :

Ancesor (F) = C, A

Descendant(C) = F,G

Parent (D) = B

Child (A) = B, C

Sibbling (F) = G

Size = 7

Height = 3

Root = A

Leaf = D,E,F,G

Degree = 2

JENIS-JENIS TREE

BINARY TREE

Tree dengan syarat bahwa tiap node hanya boleh memiliki maksimal dua sub pohon dan kedua subpohon harus terpisah.

Kelebihan struktur Binary Tree :

- Mudah dalam penyusunan algoritma sorting

- Searching data relatif cepat

- Fleksibel dalam penambahan dan penghapusan data

FULL BINARY TREE

Semua node, kecuali leaf pasti memiliki 2 anak dan tiap subpohon memiliki panjang path yang sama.

COMPLETE BINARY TREE

Tree yang mirip dengan full binary tree, tapi tiap subtree boleh memiliki panjang path yang berbeda dan tiap node (kecuali leaf) memiliki 2 anak.

SKEWED BINARY TREE

Binary tree yang semua nodenya (kecuali leaf) hanya memiliki satu anak.

IMPLEMENTASI PROGRAM TREE

Deklarasi Struct

Deklarasi Variabel

OPERASI

Create: membentuk sebuah tree baru yang kosong.

Insert: menambah node ke dalam Tree.

Jika data yang akan dimasukkan lebih besar daripada elemen root, maka akan diletakkan di node sebelah kanan, sebaliknya jika lebih kecil maka akan diletakkan di node sebelah kiri. Untuk data pertama akan menjadi elemen root.

PreOrder: cetak node yang dikunjungi, kunjungi left, kunjungi right

InOrder: kunjungi left, cetak node yang dikunjungi, kunjungi right

PostOrder: kunjungi left, kunjungi right, cetak node yang dikunjungi

Program tree :

//header file

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

//pendeklarasian struct sebuah tree awal

struct Node{

int data;

Node *kiri;

Node *kanan;

};

//fungsi untuk menambahkan node baru

void tambah(Node **root, int databaru)

{

//jika root masih kosong

if((*root) == NULL)

{

//pembuatan node baru

Node *baru;

//pengalokasian memori dari node yang telah dibuat

baru = new Node;

//inisialisasi awal node yang baru dibuat

baru->data = databaru;

baru->kiri = NULL;

baru->kanan = NULL;

(*root) = baru;

(*root)->kiri = NULL;

(*root)->kanan = NULL;

printf("Data bertambah!");

}

//jika data yang akan dimasukkan lebih kecil daripada elemen root, maka akan diletakkan di node sebelah kiri.

else if(databaru<(*root)->data)

tambah(&(*root)->kiri, databaru);

//jika data yang akan dimasukkan lebih besar daripada elemen root, maka akan diletakkan di node sebelah kanan

else if(databaru>(*root)->data)

tambah(&(*root)->kanan, databaru);

//jika saat dicek data yang akan dimasukkan memiliki nilai yang sama dengan data pada root

else if(databaru == (*root)->data)

printf("Data sudah ada!");

}

//fungsi yang digunakan untuk mencetak tree secara preOrder

void preOrder(Node *root)

{

if(root != NULL){

printf("%d ", root->data);

preOrder(root->kiri);

preOrder(root->kanan);

}

//fungsi yang digunakan untuk mencetak tree secara inOrder

void inOrder(Node *root)

{

if(root != NULL){

inOrder(root->kiri);

printf("%d ", root->data);

inOrder(root->kanan);

}

//fungsi yang digunakan untuk mencetak tree secara postOrder

void postOrder(Node *root)

{

if(root != NULL){

postOrder(root->kiri);

postOrder(root->kanan);

printf("%d ", root->data);

}

//fungsi utama

int main()

{

//deklarasikan variabel

int pil, data;// c;

Node *pohon; //*t;

pohon = NULL; //inisialisasi node pohon

//perulangan do-while

{

system("cls"); //bersihkan layar

printf("\t#PROGRAM TREE C++#");

printf("\n\t==================");

printf("\nMENU");

printf("\n----\n");

printf("1. Tambah\n");

printf("2. Lihat pre-order\n");

printf("3. Lihat in-order\n");

printf("4. Lihat post-order\n");

printf("5. Exit\n");

printf("Pilihan : ");

scanf("%d", &pil);

switch(pil)

{

//jika pil bernilai 1

case 1 :

printf("\nINPUT : ");

printf("\n-------");

printf("\nData baru : ");

scanf("%d", &data);

//panggil fungsi untuk menambah node yang berisi data pada tree

tambah(&pohon, data);

break;

//jika pil bernilai 2

case 2 :

printf("\nOUTPUT PRE ORDER : ");

printf("\n------------------\n");

if(pohon!=NULL)

//panggil fungsi untuk mencetak data secara preOrder

preOrder(pohon);

else

printf("Masih kosong!");

break;

//jika pil bernilai 3

case 3 :

printf("\nOUTPUT IN ORDER : ");

printf("\n------------------\n");

if(pohon!=NULL)

//panggil fungsi untuk mencetak data secara inOrder

inOrder(pohon);

else

printf("Masih kosong!");

break;

//jika pil bernilai 4

case 4 :

printf("\nOUTPUT POST ORDER : ");

printf("\n------------------\n");

if(pohon!=NULL)

//panggil fungsi untuk mencetak data secara postOrder

postOrder(pohon);

else

printf("Masih kosong!");

break;

}

_getch();

}while(pil != 5); //akan diulang jika input tidak samadengan 5

return EXIT_FAILURE;

}

Penjelasan :

· Pada program ini dideklarasikan sebuah struct yang didalamnya terdapat tiga field,

typedef struct Node{

int data;

Node *kiri;

Node *kanan;

};

Field pertama : variabel bertipe data integer, digunakan untuk menyimpan data pada node.

Field kedua : variable pointer yang bertipe data abstrak (NODE), digunakan untuk menunjuk node anak(child) sebelah kiri.

Field ketiga : variabel pointer yang bertipe data abtrak (NODE), digunakan untuk menunjuk node anak(child) sebelah kanan.

· Pada Tree terdapat operasi Traverse yaitu operasi kunjungan terhadap node-node dalam pohon dimana masing-masing node akan dikunjungi sekali. Dalam program ini digunakan tiga tranverse, yakni

PreOrder : node yang dikunjungi (induk), kunjungi left, kunjungi right

InOrder : kunjungi left, node yang dikunjungi (induk), kunjungi right

PostOrder : kunjungi left, kunjungi right, node yang dikunjungi (induk)

· Pada program ini dideklarasikan beberapa prorotype fungsi, yakni

1. void tambah(Node **root, int databaru)-> fungsi ini digunakan untuk melakukan penambahan node yang berisi data/nilai pada tree. Parameternya adalah variabel pointer bertipe data abstrak yaitu node dan variabel bertipe data integer(untuk menyimpan data yang diinput).

2. void preOrder(Node *root)-> fungsi ini digunakan untuk mengunjungi node secara pre-Order sekaligus mencetak isi node yang telah dikunjungi secara urut dimulai dari kunjungan yang pertama.

3. void inOrder(Node *root)-> fungsi ini digunakan untuk mengunjungi node secara in-Order sekaligus mencetak isi node yang telah dikunjungi secara urut dimulai dari kunjungan yang pertama.

4. void postOrder(Node *root)-> fungsi ini digunakan untuk mengunjungi node secara post-Order sekaligus mencetak isi node yang telah dikunjungi secara urut dimulai dari kunjungan yang pertama.

Algoritma :

1. Mulai

2. Selanjutnya deklarasikan variabel yang akan digunakan untuk melakukan penyimpanan dan pemrosesan data, serta diguanakan sebagai parameter fungsi.

int pil, data;

Node *pohon;

3. Selanjutnya jalankan perulangan do-while yang memiliki kondisi selama nilai variabel pil dari input user tidak bernilai 5.

4. Tampilkan judul program dan menu program. Jalankan operasi kondisi switch case .

Jika user memilih menu 1, maka semua pernyataan yang ada didalam case 1 akan dijalankan.

printf("\nINPUT : ");

printf("\n-------");

printf("\nData baru : ");

scanf("%d", &data);

tambah(&pohon, data);

break;

Tampilkan string, kemudian minta user menginputkan suatu bilangan yang ingin ditambah pada node tree. Bilangan yang diinputkan user disimpan dalam alamat memori variabel ‘data’ dan nantinya digunakan sebagai parameter dari fungsi “tambah(&pohon, data)”.

Program akan memanggil fungsi ‘tambah(&pohon, data)’. Berikut fungsi yang dipanggil dan dijalankan oleh program :

void tambah(Node **root, int databaru)

{

if((*root) == NULL)

{

Node *baru;

baru = new Node;

baru->data = databaru;

baru->kiri = NULL;

baru->kanan = NULL;

(*root) = baru;

(*root)->kiri = NULL;

(*root)->kanan = NULL;

printf("Data bertambah!");

}

else if(databaru<(*root)->data)

tambah(&(*root)->kiri, databaru);

else if(databaru>(*root)->data)

tambah(&(*root)->kanan, databaru);

else if(databaru == (*root)->data)

printf("Data sudah ada!");

}

- Input data pertama adalah 40

Saat pertama kali fungsi dipanggil akan dijalankan operasi kondisi if((*root) == NULL) atau if((*(&pohon)) == NULL). Karena kondisi bernilai benar maka pernyataan yang ada didalamnya akan dijalankan, yaitu pendeklarasian node baru bernama ‘baru’, kemudian dialokasikan memori untuk node yang baru dibuat.

Selanjutnya, dilakukan proses inisialisasi pada node yang baru dibuat

baru->data = databaru; -> baru-> data diisi nilai dari bilangan yang diinput (nilai dari variabel data) yaitu berisi 40.

baru->kiri = NULL;

baru->kanan = NULL;

//Node baruàkiri dan baru à kanan diinisialisasi bernilai NULL, artinya bahwa node yang baru dibuat belum memiliki anak(child).

Kemudian node yang baru dibuat (dengan nilai 40) dijadikan sebagai root melalui syntax,

(*root) = baru; atau (*(&pohon)) = baru;

(*root)->kiri = NULL; atau (*(&pohon))-> kiri = NULL;

(*root)->kanan = NULL; atau (*(&pohon))-> kanan = NULL;

//Sama halnya dengan pernyataan sebelumnya, Node (*(&pohon))-> kiri dan(*(&pohon))-> kanan diinisialisasi bernilai NULL, artinya bahwa node yang baru dibuat belum memiliki anak(child).

Setelah pembuatan node baru pada tree selesai dilakukan, akan tercetak string pada layar “Data bertambah!”.

- Input data kedua adalah 25

Saat pertama kali fungsi dipanggil akan dilakukan pengecekan melalui operasi kondisi. Karena kondisi pertama bernilai salah maka kondisi selanjutnya dijalankan. Kondisi else if(databaru<(*root)->data) dicek dan ternyata bernilai benar (25 lebih kecil daripada data pada root, yakni 40) maka pernyataan yang ada didalamnya akan dijalankan, yaitu memanggil fungsi tambah(&(*root)->kiri, databaru). Perhatikan parameter yang digunakan untuk memanggil fungsi!!!.

Selanjutnya, akan dipanggil prototype fungsi tambah(). Akan dilakukan pengecekan kondisi if((*root) == NULL) atau if((*(&(*root)->kiri) == NULL). Ternyata kondisi bernilai benar ( (*root)->kiri bernilai NULL;,pernyataan ini diperoleh dari pemanggilan fungsi sebelumnya), maka semua pernyataan yang ada didalamnya akan dijalankan, yakni pendeklarasian node baru bernama ‘baru’, kemudian dialokasikan memori untuk node yang baru dibuat.

Selanjutnya, dilakukan proses inisialisasi pada node yang baru dibuat baru->data = databaru; -> baru->data diisi nilai dari bilangan yang diinput (nilai dari variabel data) yaitu berisi 25.

baru->kiri = NULL;

baru->kanan = NULL;

//Node baruàkiri dan baru à kanan diinisialisasi bernilai NULL, artinya bahwa node yang baru dibuat belum memiliki anak(child).

Kemudian node yang baru dibuat (dengan nilai 25) dijadikan sebagai root melalui syntax,

(*root) = baru; atau *(&(*root)->kiri) = baru;

(*root)->kiri = NULL; atau *(&(*root)->kiri)-> kiri = NULL;

(*root)->kanan = NULL; atau *(&(*root)->kiri)->kanan =NULL;

//Sama halnya dengan pernyataan sebelumnya, Node *(&(*root)->kiri)-> kiridan *(&(*root)->kiri)->kanan diinisialisasi bernilai NULL, artinya bahwa node yang baru dibuat belum memiliki anak(child).

Setelah pembuatan node baru pada tree selesai dilakukan, akan tercetak string pada layar “Data bertambah!”.

- Input data ketiga adalah 50

Saat pertama kali fungsi dipanggil akan dilakukan pengecekan melalui operasi kondisi. Karena kondisi pertama dan kedua bernilai salah maka kondisi selanjutnya dijalankan. Kondisi else if(databaru>(*root)->data) dicek dan ternyata bernilai benar (50 lebih besar daripada data pada root, yakni 40) maka pernyataan yang ada didalamnya akan dijalankan, yaitu memanggil fungsi tambah(&(*root)->kanan, databaru);. Perhatikan parameter yang digunakan untuk memanggil fungsi!!!.

Selanjutnya, akan dipanggil prototype fungsi tambah(). Akan dilakukan pengecekan kondisi if((*root) == NULL) atau if((*(&(*root)->kanan) == NULL). Ternyata kondisi bernilai benar ( (*root)->kanan bernilai NULL;,pernyataan ini diperoleh dari pemanggilan fungsi sebelumnya), maka semua pernyataan yang ada didalamnya akan dijalankan, yakni pendeklarasian node baru bernama ‘baru’, kemudian dialokasikan memori untuk node yang baru dibuat.

Selanjutnya, dilakukan proses inisialisasi pada node yang baru dibuat baru->data = databaru; -> baru->data diisi nilai dari bilangan yang diinput (nilai dari variabel data) yaitu berisi 50.

baru->kiri = NULL;

baru->kanan = NULL;

//Node baruàkiri dan baru à kanan diinisialisasi bernilai NULL, artinya bahwa node yang baru dibuat belum memiliki anak(child).

Kemudian node yang baru dibuat (dengan nilai 50) dijadikan sebagai root melalui syntax,

(*root) = baru; atau *(&(*root)->kanan) = baru;

(*root)->kiri = NULL; atau *(&(*root)->kanan)-> kiri = NULL;

(*root)->kanan = NULL; atau *(&(*root)->kanan)->kanan = NULL;

//Sama halnya dengan pernyataan sebelumnya, Node *(&(*root)->kanan)-> kiridan *(&(*root)->kanan)->kanan diinisialisasi bernilai NULL, artinya bahwa node yang baru dibuat belum memiliki anak(child).

Setelah pembuatan node baru pada tree selesai dilakukan, akan tercetak string pada layar “Data bertambah!”.

Penjelasan syntax diatas adalah penjelasan bagaimana syntax bisa melakukan penambahan node dan penempatkannya di child bagian kiri ataukah kanan.

TREE YANG AKAN TERBENTUK JIKA SEMUA DATA TELAH SELESAI DIINPUT:

- Input data keempat adalah 10

1. Data baru (10) dibandingkan dengan root 40. Dilakukan pengecekan kondisi, karena 10 lebih kecil dari 40 maka akan dipanggil fungsi tambah(&(*root)->kiri, databaru). Parameter pada fungsi diubah menjadi &(*root)->kiri karena digunakan untuk menggeser posisi root ke 25.

2. Kemudian data baru (10) dibandingkan dengan root 25. Dilakukan pengecekan kondisi, karena 10 lebih kecil dari 25 maka akan dipanggil fungsi tambah(&(*root)->kiri, databaru); karena setelah penggeseran posisi root tadi maka parameter fungsinya berubah menjadi tambah(&(*(&(*root)->kiri))->kiri, databaru).

3. Karena databaru (10) bernilai lebih kecil maka akan dilakukan pendeklarasian sebagai node baru dan node baru ini akan menjadi child kiri dari node root 25.

- Input data kelima(30), keenam(45), dan ketujuh(60) memiliki algoritma yang sama dengan input data keempat dengan sedikit penyesuaian.

Jika user memilih menu 2, maka semua pernyataan yang ada didalam case 2 akan dijalankan.

PreOrder : node yang dikunjungi (induk), kunjungi left, kunjungi right

printf("\nOUTPUT PRE ORDER : ");

printf("\n------------------\n");

if(pohon!=NULL)

preOrder(pohon);

else

printf("Masih kosong!");

Saat pertama kali pernyataan yang ada dalam case 2 dijalankan, maka yang akan dilakukan program adalah melakukan pengecekan kondisi apakah pohon bernilai NULL? Jika pohon bernilai NULL artinya belum ada data sama sekali sehingga akan ditampilkan string “Masih kosong”.

Sebaliknya, jika pohon tidak sama dengan NULL, artinya sudah terbentuk node/ tree maka akan dipanggil fungsi “preOrder(pohon)”. Berikut fungsi yang dipanggil dan dijalankan oleh program :

//fungsi pertama

void preOrder(Node *root)

{

if(root != NULL){

printf("%d ", root->data);

preOrder(root->kiri);

preOrder(root->kanan);

}

Saat fungsi ini dipanggil maka akan dicek apakah kondisi bernilai NULL artinya root belum terbentuk. Jika root tidak sama dengan NULL, artinya root sudah terbentuk maka pernyataan didalamnya akan dijalankan.

Algoritma fungsi pre Order :

1. Mencetak data yang berada pada root, yaitu 40.

2. Memanggil fungsi “preOrder(root->kiri)”. Perhatikan parameternya adalah rootàkiri. Fungsi yang dipanggil,

//fungsi kedua

void preOrder(Node *(root->kiri)) //parameter berganti

{

if(root != NULL){

printf("%d ", (root->kiri)->data);

preOrder((root->kiri)->kiri);

preOrder((root->kiri)->kanan);

}

3. Mencetak data yang berada pada rootàkiri, yaitu 25.

4. Memanggil fungsi “preOrder((root->kiri)->kiri)”. Perhatikan parameternya adalah (rootà kiri)àkiri artinya menunjuk ke child sebelah kiri yang dimiliki node rootàkiri atau child kiri dari 25. Fungsi yang dipanggil,

//fungsi ketiga

void preOrder(Node *((root->kiri)->kiri)) //parameter berganti

{

if(root != NULL){

printf("%d ", ((root->kiri)->kiri)->data);

preOrder(((root->kiri)->kiri)->kiri);

preOrder(((root->kiri)->kiri)->kanan);

}

5. Mencetak data pada (rootàkiri)àkiri, yaitu 10.

6. Memanggil fungsi “preOrder(((root->kiri)->kiri)->kiri)”. Perhatikan parameternya adalah ((rootàkiri)à kiri)àkiri artinya menunjuk ke child sebelah kiri yang dimiliki node (rootàkiri)à kiri atau child kiri dari 10. Fungsi yang dipanggil,

//fungsi keempat

void preOrder(Node *(((root->kiri)->kiri)->kiri)) //parameter berganti

{

if(root != NULL){

printf("%d ", (((root->kiri)->kiri)->kiri)->data);

preOrder((((root->kiri)->kiri)->kiri)->kiri);

preOrder((((root->kiri)->kiri)->kiri)->kanan);

}

7. Karena saat dicek kondisi yang berada pada fungsi keempat tidak terpenuhi maka pernyataan yang ada didalamnya diabaikan, kemudian keluar dari fungsi keempat menuju ke fungsi yang ada satu tingkat lebih luar dari fungsi keempat, yaitu fungsi ketiga.

Pada fungsi ketiga, compiler akan menjalankan pernyataan selanjutnya yakni memanggil fungsi preOrder(((root->kiri)->kiri)->kanan);. Karena saat dicek kondisi yang berada pada fungsi keempat tidak terpenuhi maka pernyataan yang ada didalamnya diabaikan, kemudian keluar dari fungsi ketiga menuju ke fungsi yang ada satu tingkat lebih luar dari fungsi ketiga, yaitu fungsi kedua.

8. Pada fungsi kedua compiler akan menjalankan pernyataan selanjutnya, yakni memanggil fungsi “preOrder((root->kiri)->kanan)”. Perhatikan parameternya adalah (rootà kiri)àkanan artinya menunjuk ke child sebelah kanan yang dimiliki node rootà kiri atau child kanan dari 25. Fungsi yang dipanggil,

//fungsi kelima

void preOrder(Node *((root->kiri)->kanan)) //parameter berganti

{

if(root != NULL){

printf("%d ", ((root->kiri)->kanan)->data);

preOrder(((root->kiri)->kanan)->kiri);

preOrder(((root->kiri)->kanan)->kanan);

}

9. Mencetak data pada (rootàkiri)àkanan, yaitu 30.

10. Memanggil fungsi “preOrder(((root->kiri)->kanan)->kiri)”. Perhatikan parameternya adalah ((rootàkiri)à kanan)àkiri artinya menunjuk ke child sebelah kiri yang dimiliki node (rootàkiri)à kanan atau child kiri dari 30. Fungsi yang dipanggil,

//fungsi keenam

void preOrder(Node *(((root->kiri)->kanan)->kiri)) //parameter berganti

{

if(root != NULL){

printf("%d ", (((root->kiri)->kanan)->kiri)->data);

preOrder((((root->kiri)->kanan)->kiri)->kiri);

preOrder((((root->kiri)->kanan)->kiri)->kanan);

}

11. Karena saat dicek kondisi yang berada pada fungsi keenam tidak terpenuhi maka pernyataan yang ada didalamnya diabaikan, kemudian keluar dari fungsi keenam menuju ke fungsi yang ada satu tingkat lebih luar dari fungsi keenam, yaitu fungsi kelima.

Pada fungsi ketiga, compiler akan menjalankan pernyataan selanjutnya yakni memanggil fungsi preOrder(((root->kiri)->kanan)->kanan);. Karena saat dicek kondisi yang berada pada fungsi keenam tidak terpenuhi maka pernyataan yang ada didalamnya diabaikan, kemudian keluar dari fungsi kelima menuju ke fungsi yang memiliki tingkat lebih luar dari fungsi kelima, yaitu fungsi pertama.

12. Pada fungsi pertama compiler akan menjalankan pernyataan selanjutnya, yakni memanggil fungsi “preOrder(root->kanan)”. Untuk algoritma pemanggilan rootàkanan, sama dengan pemanggilan rootàkiri.

13. Jika semua node telah dikunjungi dan dat telah dicetak maka Output = 40, 25,10,30,50,45,60.

Jika user memilih menu 3, maka semua pernyataan yang ada didalam case 3 akan dijalankan.

InOrder : kunjungi left, node yang dikunjungi (induk), kunjungi right

printf("\nOUTPUT IN ORDER : ");

printf("\n------------------\n");

if(pohon!=NULL)

inOrder(pohon);

else

printf("Masih kosong!");

break;

Saat pertama kali pernyataan yang ada dalam case 3 dijalankan, maka yang akan dilakukan program adalah melakukan pengecekan kondisi apakah pohon bernilai NULL? Jika pohon bernilai NULL artinya belum ada data sama sekali sehingga akan ditampilkan string “Masih kosong”.

Sebaliknya, jika pohon tidak sama dengan NULL, artinya sudah terbentuk node/ tree maka akan dipanggil fungsi “inOrder(pohon)”. Untuk algoritma inOrder hampir mirip dengan pre Order yaitu tetap menggunakan rekursif bersarang, dimana fungsi rekursif yang berada di paling dalam dikerjakan sampai selesai terlebih dahulu, kemudian baru fungsi yang ada diluar dikerjakan.

Jika user memilih menu 4, maka semua pernyataan yang ada didalam case 4 akan dijalankan.

PostOrder : kunjungi left, kunjungi right, node yang dikunjungi (induk)

printf("\nOUTPUT POST ORDER : ");

printf("\n------------------\n");

if(pohon!=NULL)

postOrder(pohon);

else

printf("Masih kosong!");

break;

Saat pertama kali pernyataan yang ada dalam case 4 dijalankan, maka yang akan dilakukan program adalah melakukan pengecekan kondisi apakah pohon bernilai NULL? Jika pohon bernilai NULL artinya belum ada data sama sekali sehingga akan ditampilkan string “Masih kosong”.

Sebaliknya, jika pohon tidak sama dengan NULL, artinya sudah terbentuk node/ tree maka akan dipanggil fungsi “postOrder(pohon)”. Untuk algoritma postOrder hampir mirip dengan pre Order yaitu tetap menggunakan rekursif bersarang, dimana fungsi rekursif yang berada di paling dalam dikerjakan sampai selesai terlebih dahulu, baru kemudian fungsi yang ada di luar diselesaikan

Jika user memilih menu 5, maka perulangan do-while akan dihentikan dan selanjutnya keluar dari program.

5. Keluar dari pernyataan switch-case, ulang program selama input tidak samadengan 5

6. Selesai

Output :

1. Tambah data (Data yang diinput berturut-turut adalah 40, 25, 50, 10, 30, 45, 60). Output yang ditampilkan adalah output dari input data terakhir.