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


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

/*


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


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) ==


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) !=


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

/*


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

/*


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)

{


Bukan Pohon Uner Left \n", i);

}

else

{


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)

{


bukan Pohon Biner \n", i);

}

else

{


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




(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





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




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





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




(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/)”,


Utami, Nyuris. 2014. “Contoh Makalah Struktur Data Pohon Biner (Online) (http://blog-

yurisutami.blogspot.com/2014/04/contoh-makalah-struktur-data-pohon-biner.html)”,


http://dinda.dinho.blogspot.com/2013/07/pengertian-dan-konsep-binary-tree.html

http://sumbersinau.wordpress.com/2013/04/30/algoritma-dan-struktur-data-tree/)

http://blog-yurisutami.blogspot.com/2014/04/contoh-makalah-struktur-data-pohon-biner.html)

http://blog-yurisutami.blogspot.com/2014/04/contoh-makalah-struktur-data-pohon-biner.html)

Laprak Strukdat 07

Documents

Transcript of Laprak Strukdat 07