Tree pada C++ (Tree Awal) - nblognlife

Tree pada C++ (Tree Awal)

Contoh Program 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
Istilah dalam Tree


Ilustrasi alogaritma tree
Ilustrasi Algoritma 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
Binary Tree


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

Full Binary Tree


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.
Complete Binary Tree

SKEWED BINARY TREE
Binary tree yang semua nodenya (kecuali leaf) hanya memiliki satu anak.
Skewed Binary Tree

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
      do
      {
            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 fungsitambah(&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)-> kiri dan *(&(*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)-> kiri dan *(&(*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 fungsipreOrder(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 fungsipreOrder((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 fungsipreOrder(((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 fungsipreOrder((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 fungsipreOrder(((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 fungsipreOrder(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 fungsiinOrder(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 fungsipostOrder(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.
       #PROGRAM TREE C++#
       ==================
MENU
----
1. Tambah
2. Lihat pre-order
3. Lihat in-order
4. Lihat post-order
5. Exit
Pilihan : 1

INPUT :
-------
Data baru : 60
Data bertambah!

                                   
2. Lihat pre-order
       #PROGRAM TREE C++#
       ==================
MENU
----
1. Tambah
2. Lihat pre-order
3. Lihat in-order
4. Lihat post-order
5. Exit
Pilihan : 2

OUTPUT PRE ORDER :
------------------
40 25 10 30 50 45 60

            
3. Lihat in-order
       #PROGRAM TREE C++#
       ==================
MENU
----
1. Tambah
2. Lihat pre-order
3. Lihat in-order
4. Lihat post-order
5. Exit
Pilihan : 3

OUTPUT IN ORDER :
-----------------
10 25 30 40 45 50 60

                                   
4. Lihat post-order
       #PROGRAM TREE C++#
       ==================
MENU
----
1. Tambah
2. Lihat pre-order
3. Lihat in-order
4. Lihat post-order
5. Exit
Pilihan : 4

OUTPUT POST ORDER :
-------------------
10 30 25 45 60 50 40


[RS]

Klik Like & Share jika postingan ini bermanfaat
Apa tanggapan Anda?

Berikan tanggapan Anda melalui kolom komentar yang telah disediakan.
- Gunakan bahasa yang sopan;
- Saat menjadikan postingan pada blog ini sebagai referensi, jangan lupa mencantumkan sumbernya (link dari blog ini).

Jika blog ini bermanfaat jangan lupa memberikan 'like' atau 'share' untuk mendapatkan update terbaru.

Terima kasih

12 Responses to "Tree pada C++ (Tree Awal)"

  1. Replies
    1. @Aleksander Bima Sakti Wibowo Tansri
      Sama-sama. Semoga bermanfaat. Good luck! :)

      Delete
  2. terimakasih bermanfaat penjelasannya juga jelas. sehat selalu atas ilmu yang dibagikan mas

    ReplyDelete
  3. kalo inputnya beda bisa beda ya ... (?

    ReplyDelete
    Replies
    1. @Unknown
      Bentuk tree yang dihasilkan sesuai input yang dimasukkan. Bentuk treenya bisa berbeda atau sama dengan contoh di atas.

      Delete
  4. Terimakasih gan sangat bermanfaat buat latihan :)

    ReplyDelete
  5. Sip! Terimakasih banyak atas informasi yang super lengkap ini :)

    ReplyDelete