Nama : Anggi Ardhika A.

NIM : 190533646863

PTI’19 A

PROGRAM TENTANG TREE

1. Program 1 Menggunakan C++ dengan MinGwStudio

Source Code :
//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 <-");
printf("\n\t==================");
printf("\n");
printf("\nMENU");
printf("\n----------------------\n");
printf("1. Tambah Data\n");
printf("2. Lihat pre-order\n");
printf("3. Lihat in-order\n");
printf("4. Lihat post-order\n");
printf("5. Exit\n");
printf("----------------------\n");
printf("Pilihan Menu : ");
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;
}
Output Program :
1. Penambahan data
2. Lihat pre-order

3. Lihat in-order

4. Lihat post order

5. Exit

Penjelasan Program :
1. Dalam program ini digunakan header #include <stdio.h> untuk memanggil fungsi
printf , header #include <conio.h> untuk memanggil fungsi getch() guna menahan
tampilan karena program menunggu untuk diberikan karakter , dan header #include
<stdlib.h> untuk menghoperasi pembanding dan operasi konversi.
2. Pada program ini pertama kita deklarasikan fungsi struct yang didalamnya diberikan
suatu field berupa:
typedef struct Node{

   int data;
   Node *kiri;
   Node *kanan;
};
3. Membuat beberapa fungsi tambahan yaitu :
 a) Void tambah : didalamnya kita akan membuat sebuah perintah untuk
menambahkan data pada program dengan variabel pointer bertipe data abstrak
yatu node dan variabel bertipe data integer( sebagai penyimpan data)
b) Void preOrder : didalamnya kita isikan perintah perintah dimana kita akan
mengunjungi node secara pre order dan mencetak node yang tadinya telah
diinputkan secara urut dari kunjungan pertama.
c) Void inOrder : didalamnya kita berikan fungsi perintah dimana kita akan
mencetak kunjungan pada node yang ditambahkan secara urut dari node yang
pertama
d) Void postOrder : didalamnya kita berikan fungsi perintah dimana kita akan
mencetak data node yang telah ditambahkan secara ururt mulai dengan kunjungan
terakhir.
4. Selanjutnya deklarasikan variabel yang akan  digunakan untuk melakukan
penyimpanan dan pemrosesan data, serta diguanakan sebagai parameter fungsi.
                  int pil, data;
                  Node *pohon;
5. Selanjutnya jalankan perulangan do-while yang memiliki kondisi selama nilai 
variabel pil dari input user tidak bernilai 5.
6. Tampilkan judul program dan menu program. Jalankan operasi kondisi switch case
1. 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!");
}
2. 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)”.

3. 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.
 4. 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

5. Jika user memilih menu 5, maka perulangan do-while akan dihentikan dan
selanjutnya keluar dari program.
7. Program selesai
2. Program Tree dengan Java Netbeans 8.2 IDE
Source code:

package pohon;
import java.util.Random;
class Node{
int data;
Node nodeKiri;
Node nodeKanan;
public Node(int dt){
data = dt;
nodeKiri = nodeKanan = null;
}
public void sisipDt(int dtSisip){
 if (dtSisip < data){
if(nodeKiri == null)
nodeKiri = new Node ( dtSisip );
else nodeKiri.sisipDt( dtSisip );
}
else if(dtSisip > data){
if ( nodeKanan == null )
nodeKanan = new Node (dtSisip);
else nodeKanan.sisipDt( dtSisip );
}
}
}
public class Pohon {
private Node root;
public Pohon() {
root = null;
}
public void sisipDtNode(int dtSisip){
if (root == null)
root = new Node( dtSisip );
else
root.sisipDt(dtSisip);
}
public void preorderTranserval(){
preorder(root);
}
private void preorder (Node node){
if(node == null) return;
System.out.printf("%d ", node.data );
preorder(node.nodeKiri);
preorder(node.nodeKanan);
}
public void inorderTranserval(){
inorder( root );
}
private void inorder(Node node){
if (node == null) return;
inorder(node.nodeKiri);
System.out.printf("%d ", node.data );
preorder(node.nodeKanan);
}
public void postorderTranserval(){
postorder( root );
}
private void postorder (Node node){
if(node == null) return;
preorder(node.nodeKiri);
preorder(node.nodeKanan);
System.out.printf("%d ", node.data );
}
public static void main(String[] args){
Pohon Pohon = new Pohon();
int nilai;
Random randomNumber = new Random();
System.out.println("Sisip nilai data berikut ini :
");
for (int i=1; i<=10; i++){
 nilai = randomNumber.nextInt( 100 );
System.out.print(nilai + " " );
Pohon.sisipDtNode(nilai);
}
System.out.println("\n\nPreorderTranserval");
Pohon.preorderTranserval();
System.out.println("\n\nInorderTranserval");
Pohon.inorderTranserval();
System.out.println("\n\nPostorderTranserval");
Pohon.postorderTranserval();
}
}

Output Program :

Penjelasan Program :
Pada program kali ini terdapat dua class yang bernama class Node dan class
Pohon ,Kedua class tersebut mempunyai method-method, diantaranya method node
pada class Node sebagai pengatur tata letak dalam permasalahan binary tree, root
merupakan tempat menampung data yang pertama kali masuk , sedangkan child
merupakan tempat dari data lain yang baru masuk.
Apabila data yang dimasukkan lebih besar dari nilai root otomatis menjadi nilai
data child sebelah kiri, sedangkan data yang lebih kecil akan menjadi child sebelah
kanan. Preorder transversal mencetak data dengan urutan root, child kiri, child kanan,
sedangkan inorder transversal mencetak data dengan urutan child kiri, root, child kanan,
dan postorder transversal mencetak data dengan urutan child kiri, child kanan, root.
Dalam program diatas terdapat fungsi yang digunakan untuk merandom angka,
sehingga output dari setiap kali run akan berbeda atau acak, dengan batas random dari
angka 0 hingga 100, kemudian program akan menampilkan random data dengan cetak
preorder, inorder, dan postorder transversal.