Laprak Strukdat 07
-
Upload
ayoe-rieana -
Category
Documents
-
view
26 -
download
1
Transcript of Laprak Strukdat 07
BAB I
PENDAHULUAN
1.1 Dasar Teori
Tree merupakan salah satu bentuk struktur data tidak linier yang menggambarkan
hubungan yang bersifat hirarkis (hubungan one to many) antara elemen-elemen. Tree juga
dapat didefinisikan sebagai kumpulan simpul / node dengan satu elemen khusus yang disebut
root dan node lainnya terbagi menjadi himpunan-himpunan yang tak saling berhubungan satu
sama lainnya (disebut subtree). Berikut adalah istilah-istilah umum dalam tree :
Parent : predecessor satu level di atas suatu node.
Child : successor satu level di bawah suatu node.
Sibling : node-node yang memiliki parent yang sama dengan suatu node.
Subtree : bagian dari tree yang berupa suatu node beserta descendant-nya dan
memiliki semua karakteristik dari tree tersebut.
Size : banyaknya node dalam suatu tree.
Height : banyaknya tingkatan/level dalam suatu tree.
Root : satu-satunya node khusus dalam tree yang tak punya predecssor.
Leaf : node-node dalam tree yang tak memiliki seccessor.
Degree : banyaknya child yang dimiliki suatu node.
Sedangkan binary tree adalah sebuah pengorganisasian secara hirarki dari beberapa buah
simpul, dimana masing-masing simpul tidak mempunyai anak lebih dari 2. Simpul yang
berada di bawah sebuah simpul dinamakan anak (child) dari simpul tersebut. Simpul yang
berada di atas sebuah simpul dinamakan induk (parent) dari simpul tersebut.
1.2 Permasalahan
1.2.1 Lengapilah file program bintree.c dengan menambahkan nBElement.
1.2.2 Buatlah tampilan menu bintree yang berisi pilihan isTreeEmpty, isUnerLeft,
isUnerRight, isOneElement, isBin, dan nBElement.
BAB II
PEMBAHASAN
a. binTree.h
/*
Nama : Ayu Riana Devi Aprilia
Nim : 24010313120042
Judul : BinTree.h
tanggal : 28 November 2014
*/
#ifndef BINTREE_H
#define BINTREE_H
#include <stdlib.h>
#include <stdio.h>
#define nil NULL
//definisi dan spesifikasi
typedef int tipeInfo;
typedef struct tnode *address;
typedef struct tnode{
tipeInfo info;
address left;
address right;
}node;
typedef address BinTree;
typedef enum{
false, true
}boolean;
BinTree Tree (tipeInfo A, BinTree L, BinTree R);
tipeInfo Akar(BinTree BT);
BinTree Left(BinTree BT);
BinTree Right(BinTree BT);
boolean isTreeEmpty(BinTree BT);
boolean isUnerLeft(BinTree BT);
boolean isUnerRight(BinTree BT);
boolean isBin(BinTree BT);
boolean isOneElmt(BinTree BT);
void createBinTree(BinTree BT);
int nBElement(BinTree BT);
#endif
Program binTree.h pada dasarnya merupakan file header yang nantinya akan
dijadikan library oleh main program. pada program ini, terdapat pendeklarasian awal dari
procudere, selector, predikat , tipe bentukan maupun konstruktor yang digunakan.
Adapun pendeklarasian tipe bentukan, yaitu dengan menggunakan tipe data struct, tipe
data struct yang dideklarasikan ialah tipeInfo, tnode *address, tnode, struct
dari address first, dan tipe enumerasi yang menghasilkan return value boolean
yaitu true atau false.
Adapun pendeklarasian fungsi , konstruktor, selector maupun predikat dalam
program ini ialah sebagai berikut
a) BinTree Tree (tipeInfo A, BinTree L, BinTree R);
BinTree Tree merupakan suatu konstruktor. Konstruktor sendiri merupakan
fungsi yang otomatis akan dipanggil setiap kali melakukan instasiasi terhadap
suatu kelas dan digunakan untuk melakukan inisialisasi nilai dari data – data
yang terdapat di dalam kelas yang bersangkutan. Konstruktor BinTree sendiri
berfungsi untuk sebagai alokasi memori.
b) tipeInfo Akar(BinTree BT);
tipeInfo Akar merupakan suatu selector yang berfungsi untuk mengembalikan
nilai / mengirimkan nilai atau nilai dari suatu fungsi kepada fungsi yang lain
yang memanggilnya.
c) BinTree Left(BinTree BT);
Selector BinTree Left berfungsi untuk mengembalikan nilai / mengirimkan
nilai atau nilai dari suatu fungsi kepada fungsi yang lain yang memanggilnya.
d) BinTree Right(BinTree BT);
Selector BinTree Right berfungsi untuk mengembalikan nilai / mengirimkan
nilai atau nilai dari suatu fungsi kepada fungsi yang lain yang memanggilnya.
e) boolean isTreeEmpty(BinTree BT);
Boolean isTreeEmpty merupakan suatu predikat yang dapat mengirimkan
return value berupa true atau false. Dalam kasus ini, tree akan mengirimkan
nilai True jika pohon bernilai kosong.
f) boolean isUnerLeft(BinTree BT);
Boolean isUnerLeft merupakan suatu predikat yang dapat mengirimkan
return value berupa true atau false. Dalam kasus ini, tree akan mengirimkan
nilai True jika hanya memiliki ank sebelah kiri.
g) boolean isUnerRight(BinTree BT);
Boolean isUnerRight merupakan suatu predikat yang dapat mengirimkan
reurn value berupa true atau false. Dalam kasus ini, tree akan mengirimkan
nilai True jika pohon hanya memiliki anak sebelah kanan.
h) boolean isBin(BinTree BT);
Boolean isBin merupakan suatu predikat yang dapat mengirimkan return
value berupa true atau false. Dalam kasus ini, tree akan mengirimkan nilai
True jika pohon adalah pohon biner.
i) boolean isOneElmt(BinTree BT);
Boolean isOneElmt merupakan suatu predikat yang dapat mengirimkan return
value berupa true atau false. Dalam kasus ini, tree akan mengirimkan nilai
True jika pohon hanya memiliki satu elemen.
j) void createBinTree(BinTree BT);
procedure createBinTree digunakan untuk membuat/membentuk tree baru
pada program.
k) int nBElement(BinTree BT);
konstruktor int nBElement berfungsi untuk memberikan banyaknya jumlah
elemen dalam pohon biner.
b. binTree.c
/*
Nama : Ayu Riana Devi Aprilia
Nim : 24010313120042
Judul : BinTree.c
*/
#ifndef BINTREE_H
#define BINTREE_C
#include <stdio.h>
#include "BinTree.h"
//konstruktor
BinTree Tree (tipeInfo A, BinTree L, BinTree R){
//kamus lokal
address p;
//algoritma
//alokasi pointer penjelajah
p = (address) malloc (sizeof(node));
//pengisian akar
if (p != nil){
p -> info = A;
p -> left = L;
p -> right = R;
}
return p;
}
//selektor
tipeInfo Akar(BinTree BT){
//kamus lokal
//algoritma
return (BT -> info);
}
BinTree Left(BinTree BT){
//kamus lokal
//algoritma
return (BT -> left);
}
BinTree Right(BinTree BT){
//kamus lokal
//algoritma
return (BT -> right);
}
//predikat
boolean isTreeEmpty(BinTree BT){
//mengirimkan TRUE jika binary tree kosong
//kamus lokal
//algoritma
return(BT == nil);
}
boolean isUnerLeft(BinTree BT){
//mengirimkan TRUE jika pohon BT hanya mempunyai anak kiri
//kamus lokal
//algoritma
return((Right(BT) == nil) && (Left(BT) != nil));
}
boolean isUnerRight(BinTree BT){
//mengirimkan TRUE jika pohon BT hanya mempunyai anak kanan
//kamus lokal
//algoritma
return((Right (BT) != nil) && (Left(BT) == nil));
}
boolean isBin(BinTree BT){
//mengirimkan TRUE jika pohon BT adalah pohon biner
//kamus lokal
//algoritma
return((Right (BT) != nil) && (Left(BT) != nil));
}
boolean isOneElmt(BinTree BT){
//mengirimkan TRUE jika pohon BT adalah pohon yang hanya memiliki satu
elemen saja
//kamus lokal
//algoritma
return((Right (BT) == nil) && (Left(BT) == nil));
}
void createBinTree(BinTree BT){
/*
I.S : pohon biner belum trebentuk
F.S : pohon biner suah terbentuk
proses : membentuk pohon biner
*/
//kamus
//algoritma
BT = nil;
}
int nBElement(BinTree BT){
//memberikan banyaknya elemen dari pohon P
//kamus
//algoritma
int NB;
if(BT == nil){
NB = 0;
}
else
{
NB = nBElement(Left (BT)) + 1 + nBElement(Right (BT));
}
return NB;
}
#endif
Program BinTree.c pada dasarnya berisi realisasi dari prosedur maupun tipe bentukan
yang telah dideklarasikan sebelumnya pada file header BinTree.h. Dalam program ini
digunakan library stdlib.h dan stdio.h serta digunakan library dengan memanggil file
header BinTree.h. Pada program ini berisi realisasi prosedur, selector, konstruktor
maupun predikat yaitu sebagai berikut
a) BinTree Tree (tipeInfo A, BinTree L, BinTree R);
BinTree Tree merupakan konstruktor yang digunakan untuk sebagai alokasi
memori. Adapun alokasi memori dari pointer penjelajah yaitu p = (address)
malloc (sizeof(node)); dan untuk pengisian akar pada tree digunakan
struktur percabangan if dimana digunakan untuk mengecek apakah pointer
kosong atau tidak? (if (p != nil)) Jika iya maka,
p -> info = A;
p -> left = L;
p -> right = R;
Jika tidak maka, return p (mengembalikan nilai p).
b) tipeInfo Akar(BinTree BT);
selector tipeInfo Akar berfungsi untuk mengembalikan nilai / mengirimkan nilai
atau nilai dari suatu fungsi kepada fungsi yang lain yang memanggilnya. Jadi jika
dapat dikatakan bahwa tipeInfo akar akan mengirimkan nilai dari fungsi BinTree
(BT) ke info (return (BT -> info)).
c) BinTree Left(BinTree BT);
Selector BinTree Left berfungsi untuk mengembalikan nilai / mengirimkan nilai
atau nilai dari suatu fungsi kepada fungsi yang lain yang memanggilnya.
Jadi jika dapat dikatakan bahwa tipeInfo akar akan mengirimkan nilai dari fungsi
BinTree (BT) ke left (return (BT -> left)).
d) BinTree Right(BinTree BT);
Selector BinTree Right berfungsi untuk mengembalikan nilai / mengirimkan
nilai atau nilai dari suatu fungsi kepada fungsi yang lain yang memanggilnya.
Jadi jika dapat dikatakan bahwa tipeInfo akar akan mengirimkan nilai dari fungsi
BinTree (BT) ke right (return (BT -> right)).
e) boolean isTreeEmpty(BinTree BT);
Boolean isTreeEmpty digunakan untuk mengecek apakah tree kosong atu tidak?.
Pada algoritma ini terdapat nilai balik jika tree kosong (return(BT == nil))
dan akan mengirimkan return value berupa Boolean yaitu true atau false yang
pada kasus ini akan bernilai true jika tree kosong.
f) boolean isUnerLeft(BinTree BT);
Boolean isUnerLeft memiliki nilai balik jika anak sebelah kanan kosong dan anak
sebelah kiri tidak kosong (return((Right(BT) == nil) && (Left(BT) !=
nil))), dan akan mengirimkan return value berupa Boolean yaitu true atau false
yang pada kasus ini akan bernilai true jika pohon hanya memiliki anak sebelah
kiri.
g) boolean isUnerRight(BinTree BT);
Boolean isUnerRight memiliki nilai balik jika anak sebelah kanan tidak kosong
dan anak sebelah kiri kosong (return((Right(BT) != nil) && (Left(BT) ==
nil))), dan akan mengirimkan return value berupa Boolean yaitu true atau false
yang pada kasus ini akan bernilai true jika pohon hanya memiliki anak sebelah
kanan.
h) boolean isBin(BinTree BT);
Boolean isBin memiliki nilai balik jika anak sebelah kanan dan anak sebelah kiri
sama-sama tidak kosong (return((Right(BT) != nil) && (Left(BT) !=
nil))), dan akan mengirimkan return value berupa Boolean yaitu true atau false
yang pada kasus ini akan bernilai true jika pohon adalah pohon biner.
i) boolean isOneElmt(BinTree BT);
Boolean isOneElmt memiliki nilai balik jika anak sebelah kanan dan anak sebelah
kiri sama-sama kosong (return((Right(BT) == nil) && (Left(BT) ==
nil))) atau dapat dikatakan bahwa pohon hanya memiliki nilai root/akar saja ,
dan akan mengirimkan return value berupa Boolean yaitu true atau false yang
pada kasus ini akan bernilai true jika pohon hanya memiliki satu elemen saja.
j) void createBinTree(BinTree BT);
procedure createBinTree digunakan untuk membuat/membentuk tree baru pada
program.Pada algoritma program ini mengecek apakah dalam keadaan kosong
(BT = nil) jika iya maka elemen tree pertama yang diinputkan akan dibuat
k) int nBElement(BinTree BT);
konstruktor int nBElement berfungsi untuk memberikan banyaknya jumlah
elemen dalam pohon biner. Pertama-tama dicek apakah tree bernilai kosong atau
tidak? (if(BT == nil)). Jika iya maka jumlah nBElement adalah 0 (NB = 0)
dan jika tidak maka jumlah nBElement adalah jumlah anak sebelah kiri ditambah
1 ditambah jumlah anak sebelah kanan (NB = nBElement(Left (BT)) + 1 +
nBElement(Right (BT))). Dan pada konstruktor ini juga terdapat nilai balik
(return NB).
c. mfile.c
/*
Nama : Ayu Riana Devi Aprilia
Nim : 24010313120042
Judul : mfile.c
*/
#include <stdlib.h>
#include <stdio.h>
#include "BinTree.c"
int
main()
{
//kamus
BinTree A;
//algoritma
A = Tree(12, Tree
(14, Tree
(7, Tree(5, nil, Tree(9,nil,nil)),
Tree(8,nil,nil))
,nil),
Tree(17,
Tree(15,nil,
Tree(4,Tree(12,nil,nil), nil)),
Tree(4,nil,nil))
);
printf("Akar = %d \n", Akar(A)); //12
printf("Akar kiri = %d \n", Akar(Left(A))); //4
printf("Akar kiri kiri = %d \n", Akar(Left(Left(A)))); //7
printf("Akar kiri kiri kanan = %d \n",
Akar(Right(Left(Left(A))))); //8
printf("Akar kiri kiri kiri kanan = %d \n",
Akar(Right(Left(Left(Left(A)))))); //9
printf("Akar kanan = %d \n", Akar(Right(A))); //17
printf("Akar kanan kiri = %d \n", Akar(Left(Right(A)))); //15
printf("Akar kanan kanan = %d \n", Akar(Right(Right(A)))); //4
printf("Akar kanan kiri kanan = %d \n",
Akar(Right(Left(Right(A))))); //4
printf("Akar kanan kiri kanan kiri = %d \n",
Akar(Left(Right(Left(Right(A)))))); //12
getch();
return 0;
}
Program mfile ini merupakan contoh implementasi dari program yang telah dibuat
sebelumnya. Dalam mfile.c juga dilakukan pemanggilan kembali 2 program sebelumnya
yaitu BinTree.h dan BinTree.c .
Pada program ini dideklarasikan kamus berupa BinTree dengan variable A
sedangkan pada algoritmanya yaitu pertama-tama membuat suatu binary tree yang dapat
dilustrasikan sebagai berikut:
Selanjutnya adalah pemanggilan dari pohon tersebut. Jika yang dipanggil adalah
akarnya maka pemanggilannya dengan Akar (A) dan akan dicetak 12. Jika yang
dipanggil adalah anak sebelah kiri maka pemanggilannya ialah dengan Akar(Left(A)) dan
jika yang akan dipanggil adalah anak sebelah kanan, maka pemanggilannya ialah dengan
Akar(Right(A)).
Hasil compiler mfile.c
d. tugas7.c
/*
Nama : Ayu Riana Devi Aprilia
Nim : 24010313120042
Judul : tugas7.c
tanggal : 28 November 2014
*/
#include <stdlib.h>
#include <stdio.h>
#include "BinTree.c"
int
main()
{
//kamus
BinTree B[7];
int NB, i, pil;
//algoritma
B[1] = Tree(5,
Tree(2, Tree(1,nil,nil),Tree(6,nil,nil)), nil
);
B[2] = Tree(1,
nil,
Tree(4, Tree(3,nil,nil), Tree(13,nil,nil))
);
B[3] = Tree(9,
Tree(7,
Tree(4,
Tree(2,
Tree(1,nil,nil), nil),
Tree(5,
Tree(3,nil,nil), Tree(6,nil,nil))
),
nil),
Tree(10,
nil,
Tree(14,
Tree(12,nil,nil),
Tree(18,
Tree(16,
Tree(11,nil,nil), Tree(17,nil,nil)),
Tree(20,
Tree(19,nil,nil), Tree(25,nil,nil))
)
)
)
);
B[4] = Tree(50,
Tree(17,
Tree(12,
Tree(9,
Tree(2,nil,nil), nil),
Tree(14,nil,nil)
),
Tree(23,nil,nil)
),
Tree(72,
Tree(54, nil, Tree(64,nil,nil)),
Tree(76,nil,nil)
)
);
B[5] = Tree (20, nil, nil);
B[6] = nil;
//program utama
menu :
system("cls"); //digunakan untuk membersihkan layar
printf("===============================================\n");
printf("= Program Binary Tree
=\n");
printf("= Ayu Riana Devi Aprilia
=\n");
printf("= 24010313120042
=\n");
printf("===============================================\n");
printf("==================== MENU
=====================\n");
printf("\n= Pohon yang tersedia: B1, B2, B3, B4, B5, B6
=");
printf("\n= 1. Cek isTreeEmpty
=");
printf("\n= 2. Cek isUnerLeft
=");
printf("\n= 3. Cek isUnerRight
=");
printf("\n= 4. Cek isBin
=");
printf("\n= 5. Cek isOneElment
=");
printf("\n= 6. Cek nBElement(Jumlah Elemen Pohon )
=");
printf("\n= 0. Keluar
=\n");
printf("===============================================\n");
printf("Masukkan pilihan anda : "); scanf("%d",&pil);
printf("\n");
switch(pil)
{
case 1 : {
printf("\n ==============> Cek
isTreeEmpty <================\n\n");
for(i=1;i<=6;i++){
if(isTreeEmpty(B[i]) == false)
{
printf(" \tPohon B%d : Bukan
Pohon Kosong \n", i);
}
else
{
printf(" \tPohon B%d :
Pohon Kosong \n", i);
}
}
printf("
=================================================\n");
getch();
goto menu;
break;
}
case 2 : {
printf("\n\n ==============> Cek
isUnerLeft <================\n\n");
for(i=1;i<6;i++){
if(isUnerLeft(B[i]) == false)
{
printf(" \tPohon B%d :
Bukan Pohon Uner Left \n", i);
}
else
{
printf(" \tPohon B%d :
Pohon Uner Left \n", i);
}
}
printf("
================================================\n");
getch();
goto menu;
break;
}
case 3 : {
printf("\n ==============> Cek
isUnerRight <================\n\n");
for(i=1;i<6;i++){
if(isUnerRight(B[i]) ==
false)
{
printf(" \tPohon
B%d : Bukan Pohon Uner Right \n", i);
}
else
{
printf(" \tPohon
B%d : Pohon Uner Right \n", i);
}
}
printf("
=================================================\n");
getch();
goto menu;
break;
}
case 4 : {
printf("\n ===============> Cek
isBin <=================\n\n");
for(i=1;i<6;i++){
if(isBin(B[i]) == false)
{
printf(" \tPohon B%d :
bukan Pohon Biner \n", i);
}
else
{
printf(" \tPohon B%d :
Pohon Biner \n", i);
}
}
printf("
=============================================\n");
getch();
goto menu;
break;
}
case 5 : {
printf("\n ==============> Cek
isOneElement <================\n\n");
for(i=1;i<6;i++){
if(isOneElmt(B[i]) == false)
{
printf(" \tPohon B%d
Memiliki Lebih dari 1 Elemen \n", i);
}
else
{
printf(" \tPohon B%d
Hanya Memiliki 1 Elemen \n", i);
}
}
printf("
==================================================\n");
getch();
goto menu;
break;
}
case 6 : {
printf("\n ==============> Cek
nBElement <================\n\n");
for(i=1;i<=6;i++)
{
NB = nBElement(B[i]);
printf(" \tJumlah Elemen
Pohon B%d sebanyak %d\n", i, NB);
}
printf("
===============================================\n");
getch();
goto menu;
break;
}
case 0 : {
printf("\nThank you for using this
program ^_^");
printf("\n\nTekan <enter> untuk
keluar...\n");
break;
}
default : // jika user menginputkan selain case
{
printf("Masukkan salah, silakan diulangi
lagi...\n");
printf("\nPress any key to
continue...\n");
getch();
goto menu;//kembali ke label menu
}
}
getch();
return 0;
}
Program tugas7.pas adalah program utama dari unit BinTree.pas. program ini
berfungsi untuk memanggil procedure ,konstruktor, selector, hingga predikat yang telah
dibuat sebelumnya dan menampilkannya dengan tampilan menu.
Pada program ini dideklarasikan variable NB ,i, dan pil yang bertipe integer dan
variable B[7] yang brtipe BinTree dengan alokasi memory hingga 7. Penginputan tree
pada program ini ialah secara statis yaitu telah diinputkan oleh user sebelumnya pada
program. Ilustrasi dari tree tersebut dapat dilihat seperti dibawah ini.
Tree B[1] :
Tree B[2] :
Tree B[3] :
Tree B[4] :
Tree B[5] :
Tree [B6] (Tree Kosong) :
Pada program ini juga menggunakan struktur percabangan case..of yang
pengeksekusiannya ialah sebagai berikut.
1) Ketika user memilih opsi pertama
Ketika user memilih opsi pertama (Cek isEmptyTree) maka program akan
otomatis menjalankan case 1. Berdasarkan inputan pohon statis yang telah
dideklarasikan sebelumnya, maka program akan mengecek satu per satu
pohon dengan penggunakan iterasi dari i = 1 sampai i = 6
(for(i=1;i<=6;i++). Kemudian dengan iterasi tersebut, program akan
memasuki struktur percabangan if dan dilakukan pengecekan jika is
TreeEmpty pohon ke – i bernilai false (if(isTreeEmpty(B[i]) ==
false)). Jika pohon tersebut benar tidak kosong (bernilai false) maka akan
dijalankan perintah (" \tPohon B%d : Bukan Pohon Kosong \n", i)
dan jika pohon tersebut terbukti adalah pohon kosong maka program akan
menjalankan perintah (" \tPohon B%d : Pohon Kosong \n", i).
2) Ketika user memilih opsi kedua
Ketika user memilih opsi pertama (Cek isUnerLeft) maka program akan
otomatis menjalankan case 2. Berdasarkan inputan pohon statis yang telah
dideklarasikan sebelumnya, maka program akan mengecek satu per satu
pohon dengan penggunakan iterasi dari i = 1 sampai i = 5
(for(i=1;i<6;i++). Kemudian dengan iterasi tersebut, program akan
memasuki struktur percabangan if dan dilakukan pengecekan jika isUnerLeft
pohon ke – i bernilai false (if(isUnerLeft (B[i]) == false)). Jika
pohon tersebut tidak hanya memiliki anak sebelah kiri saja disini dalam
artian pohon memiliki cabang anak kiri dan kanan, pohon hanya memiliki
satu elemen, dan juga pohon kosong (bernilai false) maka akan dijalankan
perintah (" \tPohon B%d : Bukan Pohon Uner Left \n", i) dan jika
pohon tersebut terbukti adalah pohon yang hanya memiliki anak sebelah kiri
saja maka program akan menjalankan perintah (" \tPohon B%d : Pohon
Uner Left \n", i).
3) Ketika user memilih opsi ketiga
Ketika user memilih opsi pertama (Cek isUnerRight) maka program akan
otomatis menjalankan case 3. Berdasarkan inputan pohon statis yang telah
dideklarasikan sebelumnya, maka program akan mengecek satu per satu
pohon dengan penggunakan iterasi dari i = 1 sampai i = 5
(for(i=1;i<6;i++). Kemudian dengan iterasi tersebut, program akan
memasuki struktur percabangan if dan dilakukan pengecekan jika
isUnerRight pohon ke – i bernilai false (if(isUnerRight(B[i]) ==
false)). Jika pohon tersebut tidak hanya memiliki anak sebelah kanan saja
disini dalam artian pohon memiliki cabang anak kiri dan kanan, pohon hanya
memiliki satu elemen, dan juga pohon kosong (bernilai false) maka akan
dijalankan perintah (" \tPohon B%d : Bukan Pohon Uner Right \n",
i) dan jika pohon tersebut terbukti adalah pohon yang hanya memiliki anak
sebelah kanan saja maka program akan menjalankan perintah (" \tPohon
B%d : Pohon Uner Right \n", i).
4) Ketika user memilih opsi keempat
Ketika user memilih opsi pertama (Cek isBin) maka program akan otomatis
menjalankan case 4. Berdasarkan inputan pohon statis yang telah
dideklarasikan sebelumnya, maka program akan mengecek satu per satu
pohon dengan penggunakan iterasi dari i = 1 sampai i = 5
(for(i=1;i<6;i++). Kemudian dengan iterasi tersebut, program akan
memasuki struktur percabangan if dan dilakukan pengecekan jika isBin
pohon ke – i bernilai false (if(isBin(B[i]) == false)). Jika pohon
tersebut hanya memiliki anak sebelah kiri atau kanan saja , pohon hanya
memiliki satu elemen, dan juga pohon kosong (bernilai false) maka akan
dijalankan perintah (" \tPohon B%d : Bukan Pohon Biner \n", i)
dan jika pohon tersebut terbukti adalah pohon yang memiliki anak sebelah
kiri dan anak sebelah kanan maka program akan menjalankan perintah ("
\tPohon B%d : Pohon Biner \n", i).
5) Ketika user memilih opsi kelima
Ketika user memilih opsi pertama (Cek isOneElement) maka program akan
otomatis menjalankan case 5. Berdasarkan inputan pohon statis yang telah
dideklarasikan sebelumnya, maka program akan mengecek satu per satu
pohon dengan penggunakan iterasi dari i = 1 sampai i = 5
(for(i=1;i<6;i++). Kemudian dengan iterasi tersebut, program akan
memasuki struktur percabangan if dan dilakukan pengecekan jika isOneElmt
pohon ke – i bernilai false (if(isOneElmt(B[i]) == false)). Jika pohon
tersebut tidak hanya memiliki satu elemen saja, disini dalam artian pohon
memiliki anak sebelah kiri atau kanan saja, memiliki anak kanan dan anak
kiri dan juga pohon kosong (bernilai false) maka akan dijalankan perintah ("
\tPohon B%d Memiliki Lebih dari 1 Elemen \n", i) dan jika pohon
tersebut terbukti adalah pohon yang memiliki satu elemen saja maka program
akan menjalankan perintah (" \tPohon B%d Hanya Memiliki 1 Elemen
\n", i).
6) Ketika user memilih opsi keenam
Ketika user memilih opsi pertama (Cek nBElement) maka program akan
otomatis menjalankan case 6. Berdasarkan inputan pohon statis yang telah
dideklarasikan sebelumnya, maka program akan mengecek satu per satu
pohon dengan penggunakan iterasi dari i = 1 sampai i = 6
(for(i=1;i<=6;i++). Kemudian dengan iterasi tersebut, program akan
memanggil konstruktor nBElement yang telah dideklarasikan dalam
BinTree.c sebelumnya NB = nBElement(B[i]). Kemudian setelah
dilakukan pemanggilan dan ditemukan hasil jumlahnya maka pogram akan
menjalankan perintah (" \tJumlah Elemen Pohon B%d sebanyak %d\n",
i, NB).
7) Ketika user memilih opsi ketujuh
Ketika user memilih opsi 0 pada submenu, maka program akan menampilkan
pesan “Thank you for using this program ^_^” dan program akan
otomatis keluar.
8) Ketika user memilih selain opsi pada sub menu
Ketika user memilih selain submenu, misal memilih 9 maka program akan
menampilkan pesan kesalahan “Masukkan salah, silakan diulangi
lagi ..' dan kemudian program akan otomatis kembali ke menu utama.
Tampilan awal program
Tampilan ketika memilih opsi pertama
Tampilan ketika memilih opsi kedua
Tampilan ketika memilih opsi ketiga
Tampilan ketika memilih opsi keempat
Tampilan ketika memilih opsi kelima
Tampilan ketika memilih opsi keenam
Tampilan ketika memilih opsi selain sub menu
Tampilan ketika memilih opsi ketujuh
BAB III
KESIMPULAN
Dalam struktur data, tree merupakan kumpulan node yang saling terhubung satu sama
lain dan membentuk satu hierarki yang secara grafis mirip dengan pohon. Sedangkan binary tree
adalah pohon / tree dengan syarat bahwa setiap node hanya boleh mempunyai maksimal dua sub
pohon dan harus terpisah.
Dalam algoritma binary tree ini, tedapat beberapa pengecekan yang harus dilakukan
diantaranya ialah pengecekan isTreeEmpty yang berfungsi untuk mengecek apakah pohon
kosong atau tidak, isUnerLeft mengecek apakah pohon hanya memiliki anak kiri saja,
isUnerRight mengecek apakah pohon hanya memiliki anak kanan saja, isBin mengecek apakah
pohon tersebut biner, isOneElmt mengecek apakah pohon tersebut hanya memiliki satu elemen
saja dan nBElement yaitu untuk mengirimkan banyaknya jumlah elemen pohon biner.
DAFTAR PUSTAKA
Adimanggala, Dinda. 2013. “Pengertian dan Kosep Binary Tree (Online)
(http://dinda.dinho.blogspot.com/2013/07/pengertian-dan-konsep-binary-tree.html)”
diakses pada 4 Desember 2014.
Siswantoro, Hendra. 2013. “Algoritma dan Struktur Data Tree (Online)
(http://sumbersinau.wordpress.com/2013/04/30/algoritma-dan-struktur-data-tree/)”,
diakses pada 4 Desember 2014.
Utami, Nyuris. 2014. “Contoh Makalah Struktur Data Pohon Biner (Online) (http://blog-
yurisutami.blogspot.com/2014/04/contoh-makalah-struktur-data-pohon-biner.html)”,
diakses pada 4 Desember 2014.