LAPORAN PRAKTIKUM

STRUKTUR DATA
Praktikum 16

Disusun oleh:

Nama : Desi Maya Sari

NIM : 2107110665
Dosen : T. Yudi Hadiwandra, S.Kom, M.Kom
Asisten : 1. Mamba Ul Izzi (1807124814)
2. Rifqi Al Hanif Simbolon (1807195430)

PROGRAM STUDI TEKNIK INFORMATIKA

FAKULTAS TEKNIK
UNIVERSITAS RIAU
GENAP 2021/2022
A. TUGAS PENDAHULUAN
1. Flowchart tree

Start

int data;Node
*kiri;Node
*kanan;

Masukan
tambah
data

hapus Hapus data

Tampilkan
tampil
data

end

1
B. PERCOBAAN
Percobaan 1 : Membangun Tree Baru
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct tree *pohon;
/* Deklarasi dari tree dengan menggunakan linked list */
struct tree
{
char
info;
pohon
kiri;
pohon
kanan;
};
/* Fungsi untuk membuat simpul yang pertama */
pohon baru(char hrf)
{
pohon br;
br = (pohon)malloc(sizeof(struct tree));
br->info = hrf;
br->kiri = NULL;
br->kanan = NULL;
return (br);
}
/*
Fungsi untuk menyisipkan simpul pada tree yang sudah dibangun
*/
void sisip(pohon ph, pohon sp)
{
pohon P, Q;
P = ph;
Q = ph;
while ((sp->info != ph->info) && (Q != NULL))
{
P = Q;
if (sp->info < P->info)
Q = P->kiri;
else
Q = P->kanan;
}
if (sp->info == P->info)
printf("Sudah ada");
else if (sp->info < P->info)

3
 P->kiri = sp;
else
P->kanan = sp;
}
/*
Fungsi-fungsi untuk metode traversal secara rekurs
*/
void preorder(pohon ph)
{
if (ph != NULL)
{
printf("%c ", ph->info);
preorder(ph->kiri);
preorder(ph->kanan);
}
}
void inorder(pohon ph)
{
if (ph != NULL)
{
inorder(ph->kiri);
printf("%c ", ph->info);
inorder(ph->kanan);
}
}
void postorder(pohon ph)
{
if (ph != NULL)
{
postorder(ph->kiri);
postorder(ph->kanan);
printf("%c ", ph->info);
}
}
main()
{
int j = 0;
char input, jawab[2];
pohon br, ssp;
while (1)
{
printf("Ketikkan huruf :");
scanf("%c", &input);
fflush(stdin);
if (j == 0)
br = baru(input);

4
 else
{
ssp = baru(input);
sisip(br, ssp);
}
printf("Ada data lagi(y/t):");
scanf("%s", &jawab);
fflush(stdin);
if ((strcmp(jawab, "Y") == 0) || (strcmp(jawab, "y") == 0))
{
j++;
continue;
}
else if ((strcmp(jawab, "T") == 0) || (strcmp(jawab, "t")
== 0))
break;
}
preorder(br);
printf("\n");
inorder(br);
printf("\n");
postorder(br);
}

5
C. LATIHAN
1. TUJUAN PRAKTIKUM

Praktikum ini bertujuan agar mahasiswa memahami:

1. Mampu membuat struktur pohon (tree) dengan menggunakan array.
2. Mampu membuat flowchart pembentukan tree dengan menggunakan
struktur data list.
3. Mampu mengimplementasikan tree sesuai flowchart yang sudah
dibuat.

6
2. DASAR TEORI
Struktur pohon (tree) biasanya digunakan untuk menggambarkan
hubungan yang bersifat hirarkis antara elemen-elemen yang ada. Contoh
penggunaan struktur pohon :
• Silsilah keluarga
• Hasil pertandingan yang berbentuk turnamen
• Struktur organisasi dari sebuah perusahaan
Sebuah 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 dari simpul tersebut. Simpul yang berada di atas sebuah simpul
dinamakan induk dari simpul tersebut.
Masing-masing simpul dalam binary tree terdiri dari tiga bagian yaitu
sebuah data dan dua buah pointer yang dinamakan pointer kiri dan kanan.
Simpul juga mempunyai sibling, descendants, dan ancestors. Sibling dari
sebuah simpul adalah anak lain dari induk simpul tersebut. Descendants
dari sebuah simpul adalah semua simpul-simpul merupakan cabang
(berada di bawah) simpul tersebut. Anchestors dari sebuah simpul adalah
semua simpul yang berada di atas antara simpul tersebut dengan root.
Penampilan dari sebuah tree akan ditampilkan dengan berat dari tree
tersebut, angka yang menunjukkan jumlah level yang ada di dalamnya.

Tingkat suatu simpul ditentukan dengan pertama kali menentukan akar

sebagai bertingkat 1. Jika suatu simpul dinyatakan sebagai tingkat N,
maka simpul-simpul yang merupakan anaknya akan berada pada
tingkatan N + 1.

Tinggi atau kedalaman dari suatu pohon adalah tingkat maksimum dari
simpul dalam pohon dikurangi dengan 1. Selain tingkat, juga dikenal
istilah derajad (degree) dari suatu simpul. Derajad suatu simpul
dinyatakan sebagai banyaknya anak atau turunan dari simpul tersebut.

7
3. PEMBAHASAN
Berdasarkan program yang terdapat pada praktikum ini menggunakan
beberapa syntax sebagai berikut :
#include <iostream>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Selanjutnya menggunakan tipe data int dan char, serta menggunakan
perulangan for.

8
4. HASIL
Latihan 1: Implementasikan tree untuk persamaan matematika seperti
yang ada dalam Dasar Teori, yang mana flowchart-nya sudah anda buat
dalam Tugas Pendahuluan.

Penjelasan:
Program diatas adalah program untuk menambahkan data tree, melihat
preorder, inorder, postorder, dan menu-menu yang sesuai dengan pada
gambar output.

9
Latihan 2: Buatlah fungsi yang menampilkan isi dari tree dengan metode
traversal tanpa proses rekursif.

Penjelasan:
Output Program tersebut merupakan fungsi yang menampilkan isi dari
tree dengan metode traversal tanpa proses rekursif.

10
Latihan 3: Buatlah fungsi untuk mengetahui jumlah simpul di tree yang
telah dibangun

Penjelasan:
Program diatas akan menampilkan jumlah simpul dari sebuah tree yang
telah dibangun.

11
Latihan 4: Buatlah fungsi untuk mengetahui kedalaman maksimum dari
tree yang telah dibangun.

Penjelasan:
Program ini berfungsi untuk mengetahui kedalaman maksimum dari tree
yang telah dibangun dari simpul yang telah dimasukkan.

12
5. KESIMPULAN

Sebuah binary tree adalah sebuah pengorganisasian secara hirarki

dari beberapa buah simpul, dimana masing-masing simpul tidak
mempunyai anak lebih dari 2. Pohon biner dapat disajikan secara
berurutan dengan menggunakan array atau file. Untuk itu diperlukan
adanya satu aturan tertentu dengan mengingat definisi pohon biner. Pohon
yang mempunyai kedalaman N mempunyai simpul maksimum 2(N-1),
dengan N adalah kedalaman simpul. Sebagai contoh pohon dengan
kedalaman 4, mempunyai simpul secara keseluruhan (dari tingkat 1
sampai dengan 4) adalah 15 buah.

13
6. LISTING PROGRAM
Latihan 1 : Program tree
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

typedef struct Node

{
int data;
Node *kiri;
Node *kanan;
};
Node *pohon = NULL;

void tambahData(Node **root, int Data)

{
if ((*root) == NULL)
{
Node *baru;
baru = new Node;
baru->data = Data;
baru->kiri = NULL;
baru->kanan = NULL;
(*root) = baru;
(*root)->kiri = NULL;
(*root)->kanan = NULL;
printf("Data Bertambah!");
}
else if (Data < (*root)->data)
tambahData(&(*root)->kiri, Data);
else if (Data > (*root)->data)
tambahData(&(*root)->kanan, Data);
else if (Data == (*root)->data)
printf("Data Sudah ada!");
}

void preOrder(Node *root)

{
if (root != NULL)
{
if (root->data != NULL)
{
printf("%d ", root->data);
}
preOrder(root->kiri);
preOrder(root->kanan);
}

14
}

void inOrder(Node *root)

{
if (root != NULL)
{
inOrder(root->kiri);
if (root->data != NULL)
{
printf("%d ", root->data);
}
inOrder(root->kanan);
}
}

void postOrder(Node *root)

{
if (root != NULL)
{
postOrder(root->kiri);
postOrder(root->kanan);
if (root->data != NULL)
{
printf("%d ", root->data);
}
}
}

void search(Node **root, int cariData)

{
if ((*root) == NULL)
printf("Data tidak ditemukan!");
else if (cariData < (*root)->data)
search(&(*root)->kiri, cariData);
else if (cariData > (*root)->data)
search(&(*root)->kanan, cariData);
else if (cariData == (*root)->data)
printf("Data ditemukan!");
}

int count(Node *root)

{
if (root == NULL)
return 0;
else
return count(root->kiri) + count(root->kanan) + 1;
}

int height(Node *root)

{

15
 if (root == NULL)
return -1;
else
{
int u = height(root->kiri);
int v = height(root->kanan);
if (u > v)
return u + 1;
else
return v + 1;
}
}

void hapusData(Node **root, int hapus)

{
Node *curr;
Node *parent;
curr = (*root);
bool flag = false;

while (curr != NULL)

{
if (curr->data == hapus)
{
flag = true;
break;
}
else
{
parent = curr;
if (hapus > curr->data)
curr = curr->kanan;
else
curr = curr->kiri;
}
}
if (!flag)
{
cout << "Data tidak ditemukan. Penghapusan tidak
dilakukan." << endl;
return;
}
if (height(pohon) == 0)
{
if (curr->kiri == NULL && curr->kanan == NULL)
{
(*root) = NULL;
return;
}
}

16
else if (height(pohon) > 0)
{
if (curr->kiri == NULL && curr->kanan == NULL)
{
if (parent->kiri == curr)
{
parent->kiri = NULL;
delete curr;
}
else
{
parent->kanan = NULL;
delete curr;
}
return;
}

if ((curr->kiri == NULL && curr->kanan != NULL) ||

(curr->kiri != NULL && curr->kanan == NULL))
{

if (curr->kiri == NULL && curr->kanan != NULL)

{
if (parent->kiri == curr)
{
parent->kiri = curr->kanan;
delete curr;
}
else
{
parent->kanan = curr->kanan;
delete curr;
}
}
else
{

if (parent->kiri == curr)
{
parent->kiri = curr->kiri;
delete curr;
}
else
{
parent->kanan = curr->kiri;
delete curr;
}
}
return;
}

17
 if (curr->kiri != NULL && curr->kanan != NULL)
{
Node *bantu;
bantu = curr->kanan;
if ((bantu->kiri == NULL) && (bantu->kanan == NULL))
{
curr = bantu;
delete bantu;
curr->kanan = NULL;
}
else
{
if ((curr->kanan)->kiri != NULL)
{
Node *bantu2;
Node *bantu3;
bantu3 = curr->kanan;

bantu2 = (curr->kanan)->kiri;

while (bantu2->kiri != NULL)

{
bantu3 = bantu2;
bantu2 = bantu2->kiri;
}

curr->data = bantu2->data;
delete bantu2;
bantu3->kiri = NULL;
}
else
{
Node *tmp;
tmp = curr->kanan;

curr->data = tmp->data;
curr->kanan = tmp->kanan;
delete tmp;
}
}
return;
}
}
}

int main()
{
char pil;
int hapus, cariData;
while (true)

18
{
system("cls");
char data;
printf("\n\t====================\n");
printf("\t\tTREE");
printf("\n\t====================\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. Delete\n");
printf("6. Kosongkan Data\n");
printf("7. Search\n");
printf("8. Hitung Node pada Tree\n");
printf("9. Kedalaman Tree\n");
printf("\nX. Keluar\n");
printf("Pilihan Anda : ");
scanf("%c", &pil);
fflush(stdin);
switch (pil)
{
// jika pil '1'
case '1':
printf("\nINPUT : ");
printf("\n-------");
printf("\nMasukkan data: ");
scanf("%d", &data);
tambahData(&pohon, data);
getch();
break;
// jika pil '2'
case '2':
printf("\nOUTPUT PRE ORDER : ");
printf("\n------------------\n");
if (pohon != NULL)
preOrder(pohon);
else
printf("Masih Kosong!!!");

getch();
break;

// jika pil '3'

case '3':
printf("\nOUTPUT IN ORDER : ");
printf("\n------------------\n");
if (pohon != NULL)
inOrder(pohon);
else
printf("Masih Kosong!!!");

19
 getch();
break;
// jika pil '4'
case '4':
printf("\nOUTPUT POST ORDER : ");
printf("\n------------------\n");
if (pohon != NULL)
postOrder(pohon);
else
printf("Masih Kosong!!!");
getch();
break;

// jika pil '5'

case '5':
if (pohon != NULL)
{
printf("\nSEBELUM NODE DIHAPUS : ");
printf("\n---------------------- ");
printf("\nPRE ORDER : ");
preOrder(pohon);
printf("\nIN ORDER : ");
inOrder(pohon);
printf("\nPOST ORDER : ");
postOrder(pohon);
printf("\n\nPENGHAPUSAN DATA : ");
printf("\n------------------\n");
printf("Masukkan data yang ingin dihapus: ");
scanf("%d", &hapus);

hapusData(&pohon, hapus);
printf("\n\nSETELAH NODE DIHAPUS : ");
printf("\n---------------------- ");
printf("\nPRE ORDER : ");
preOrder(pohon);
printf("\nIN ORDER : ");
inOrder(pohon);
printf("\nPOST ORDER : ");
postOrder(pohon);
}
else
printf("\nMasih kosong!");
getch();
break;
// jika pil '6'
case '6':
pohon = NULL;
printf("\nPENGOSONGAN ELEMEN ");
printf("\n------------------");

20
 printf("\nTree sudah dikosongkan!!");

getch();
break;
// jika pil '7'
case '7':
printf("\nOUTPUT -> Hanya untuk mengecek apakah data
dimaksud terdapat dalam tree");
printf("\n------");
if (pohon != NULL)
{
printf("\nPRE ORDER : ");
preOrder(pohon);
printf("\nIN ORDER : ");
inOrder(pohon);
printf("\nPOST ORDER : ");
postOrder(pohon);
printf("\n\nPENCARIAN DATA");
printf("\n--------------");
printf("\nMasukkan data yang ingin dicari : ");
scanf("%d", &cariData);
search(&pohon, cariData);
}
else
printf("\nMasih kosong!");
getch();
break;
// jika pil '8'
case '8':
printf("\nJUMLAH NODE DI DALAM TREE");
printf("\n-------------------------");
printf("\nJumlah Node : %d", count(pohon));

getch();
break;

// jika pil '9'

case '9':
printf("\nKEDALAMAN TREE(LEVEL-> DIMULAI DARI 0)");
printf("\n----------------------------------------");
printf("\nKedalaman tree : %d\n", height(pohon));

getch();
break;

// jika pil 'X' atau 'x'

case 'X' | 'x':
exit(0);
break;
}

21
 }
}

22
Latihan 2 : Program untuk menampilkan isi dari tree
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
typedef struct Node
{
int data;
Node *kiri;
Node *kanan;
};
Node *pohon = NULL;
void tambahData(Node **root, int Data)
{
if ((*root) == NULL)
{
Node *baru;
baru = new Node;
baru->data = Data;
baru->kiri = NULL;
baru->kanan = NULL;
(*root) = baru;
(*root)->kiri = NULL;
(*root)->kanan = NULL;
printf("Data Bertambah!");
}
else if (Data < (*root)->data)
tambahData(&(*root)->kiri, Data);
else if (Data > (*root)->data)
tambahData(&(*root)->kanan, Data);
else if (Data == (*root)->data)
printf("Data Sudah ada!");
}
void tampil(Node *root)
{
if (root != NULL)
{
if (root->data != NULL)
{
printf("%d ", root->data);
}
tampil(root->kiri);
tampil(root->kanan);
}
}

23
int main()
{
char pil;
int del, cari;
while (true)
{
system("cls");
char data;
printf("\n\t====================\n");
printf("\t\tTREE");
printf("\n\t====================\n");
printf("1. Tambah Data\n");
printf("2. Lihat\n");
printf("X. Keluar\n");
printf("Pilihan Anda : ");
scanf("%c", &pil);
fflush(stdin);

switch (pil)
{
// jika pil bernilai '1'
case '1':
printf("\nINPUT : ");
printf("\n-------");
printf("\nMasukkan data: ");
scanf("%d", &data);
tambahData(&pohon, data);
getch();
break;
// jika pil bernilai '2'
case '2':
printf("\nOUTPUT : ");
printf("\n------------------\n");
if (pohon != NULL)
tampil(pohon);
else
printf("Masih Kosong!!!");
getch();
break;
// jika pil bernilai 'X' atau 'x'
case 'X' | 'x':
exit(0);
break;
}
}
}

24
Latihan 3 : Program untuk menampilkan jumlah simpul di tree
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

typedef struct Node

{
int data;
Node *kiri;
Node *kanan;
};
Node *pohon = NULL;

void tambahData(Node **root, int Data)

{
if ((*root) == NULL)
{
Node *baru;
baru = new Node;
baru->data = Data;
baru->kiri = NULL;
baru->kanan = NULL;
(*root) = baru;
(*root)->kiri = NULL;
(*root)->kanan = NULL;
printf("Data Bertambah!");
}
else if (Data < (*root)->data)
tambahData(&(*root)->kiri, Data);
else if (Data > (*root)->data)
tambahData(&(*root)->kanan, Data);
else if (Data == (*root)->data)
printf("Data Sudah ada!");
}

void tampil(Node *root)

{
if (root != NULL)
{
if (root->data != NULL)
{
printf("%d ", root->data);
}
tampil(root->kiri);
tampil(root->kanan);
}
}

25
int count(Node *root)
{
if (root == NULL)
return 0;
else
return count(root->kiri) + count(root->kanan) + 1;
}
int main()
{
char pil;
int del, cari;
while (true)
{
system("cls");
char data;
printf("\n\t====================\n");
printf("\t\tTREE");
printf("\n\t====================\n");
printf("1. Tambah Data\n");
printf("2. Lihat\n");
printf("3. Hitung Simpul pada Tree\n");
printf("X. Keluar\n");
printf("Pilihan Anda : ");
scanf("%c", &pil);
fflush(stdin);

switch (pil)
{
// jika pil bernilai '1'
case '1':
printf("\nINPUT : ");
printf("\n-------");
printf("\nMasukkan data: ");
scanf("%d", &data);
tambahData(&pohon, data);
getch();
break;
// jika pil bernilai '2'
case '2':
printf("\nOUTPUT : ");
printf("\n------------------\n");
if (pohon != NULL)
tampil(pohon);
else
printf("Masih Kosong!!!");

getch();
break;

// jika pil bernilai '8'

26
 case '3':
printf("\nJUMLAH NODE DI DALAM TREE");
printf("\n-------------------------");
printf("\nJumlah Simpul : %d", count(pohon));

getch();
break;

// jika pil bernilai 'X' atau 'x'

case 'X' | 'x':
exit(0);
break;
}
}
}

27
Latihan 4 : Program untuk mengetahui kedalaman maksimum dari tree
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

typedef struct Node

{
int data;
Node *kiri;
Node *kanan;
};
Node *pohon = NULL;

void tambahData(Node **root, int Data)

{
if ((*root) == NULL)
{
Node *baru;
baru = new Node;
baru->data = Data;
baru->kiri = NULL;
baru->kanan = NULL;
(*root) = baru;
(*root)->kiri = NULL;
(*root)->kanan = NULL;
printf("Data Bertambah!");
}
else if (Data < (*root)->data)
tambahData(&(*root)->kiri, Data);
else if (Data > (*root)->data)
tambahData(&(*root)->kanan, Data);
else if (Data == (*root)->data)
printf("Data Sudah ada!");
}

void tampil(Node *root)

{
if (root != NULL)
{
if (root->data != NULL)
{
printf("%d ", root->data);
}
tampil(root->kiri);
tampil(root->kanan);
}
}

28
int tinggi(Node *root)
{
if (root == NULL)
return -1;
else
{
int u = tinggi(root->kiri);
int v = tinggi(root->kanan);
if (u > v)
return u + 1;
else
return v + 1;
}
}

int main()
{
char pil;
int del, cari;
while (true)
{
system("cls");
char data;
printf("\n\t====================\n");
printf("\t\tTREE");
printf("\n\t====================\n");
printf("1. Tambah Data\n");
printf("2. Lihat\n");
printf("3. Kedalaman Tree\n");
printf("X. Keluar\n");
printf("Pilihan Anda : ");
scanf("%c", &pil);
fflush(stdin);

switch (pil)
{
// jika pil bernilai '1'
case '1':
printf("\nINPUT : ");
printf("\n-------");
printf("\nMasukkan data: ");
scanf("%d", &data);
tambahData(&pohon, data);
getch();
break;
// jika pil bernilai '2'
case '2':
printf("\nOUTPUT : ");
printf("\n------------------\n");
if (pohon != NULL)

29
 tampil(pohon);
else
printf("Masih Kosong!!!");
getch();
break;
// jika pil bernilai '9'
case '3':
printf("\nKEDALAMAN TREE(LEVEL-> DIMULAI DARI 0)");
printf("\n----------------------------------------");
printf("\nKedalaman tree : %d\n", tinggi(pohon));

getch();
break;
// jika pil bernilai 'X' atau 'x'
case 'X' | 'x':
exit(0);
break;
}
}
}

30