TUGAS AKHIR

STRUKTUR DATA

PENYUSUN:
STACK : <192028> <Andi Hasriadi Putra>
QUEUE: <192010> <A. Nur Fadli Dzil Jalal>
LINKED LIST: <192031k> <Marvin Mathwell K.>
BINARY TREE: <192021> <Ahmad Rafiuddin>

STMIK DIPANEGARA MAKASSAR

TEKNIK INFORMATIKA
2020
1. Tumpukan (stack)
Tumpukan (stack) adalah suatu stuktur data yang penting dalam
pemrograman yang mempunyai sifat LIFO (Last In First Out), Benda yang
terakhir masuk ke dalam stack akan menjadi benda pertama yang dikeluarkan
dari stack. Stack (Tumpukan) adalah list linier yang dikenali elemen
puncaknya (TOP) dan Aturan penyisipan dan penghapusan elemennya
tertentu. Penyisipan selalu dilakukan “di atas“ TOP dan Penghapusan selalu
dilakukan pada TOP.
Stack karena aturan penyisipan dan penghapusan semacam itu, TOP adalah
satu-satunya alamat tempat terjadi operasi. Elemen yang ditambahkan paling
akhir akan menjadi elemen yang akan dihapus.Dikatakan bahwa elemen Stack
akan tersusun secara LIFO (Last In First Out).

karena kita menumpuk Compo di posisi terakhir, maka Compo akan

menjadi elemen teratas dalam tumpukan. Sebaliknya, karena kita menumpuk
Televisi pada saat pertama kali, maka elemen Televisi menjadi elemen
terbawah dari tumpukan. Dan jika kita mengambil elemen dari tumpukan, maka
secara otomatis akan terambil elemen teratas, yaitu Compo juga.

a. Konsep stack
Dari penerapan di atas bisa di simpulkan bahwa stack itu mempunyai
konsep LIFO (Last In First Out) artinya terakhir kali di masukkan akan
keluar dahulu, maksudnya jika kita membuat tumpukan dari atas ke bawah
seperti penerapan di atas, maka Ketika kita mengambil satu persatu
tumpukan tersebut pasti dari atas ke bawah bukan? Tidak mungkin dari
bawah ke atas karena akan menghambat waktu.

b. Operasi operasi pada stack

suatu stack memiliki beberapa operasi yang dapat diterapkan seperti
membuat stack, penambahan eleme ke dalam stack, menghapusan elemen
 dari dalam stack, dan operasi lain yang berhubungan dengan stack tersebut.
Adapun operasi-operasi dasar dari suatu stack adalah :

1. Create(Stack)
Operasi Create(Stack) digunakan untuk membuat
suatu stack baru dengan nama stack, yang nilai elemen
saat stack tersebut dibuat adalah NOEL(S) = 0, TOP(S) = NULL (tidak
terdefinisikan)

2. IsEmpty(Stack)
Operasi ini merupakan operasi untuk mencek isi dari
suatu stack dalam keadaan kosong atau berisi. Operasi ini memiliki 2
(dua) kondisi boolean yaitu :
a. True jika stack tersebut kosong atau dapat dikatakan NOEL(S) = 0
b.False jika stack tersebut tidak dalam kondisi kosong atau dapat
dikatakan NOEL(S) > 0c)

3. Push(Stack, Elemen)
Operasi ini merupakan operasi untuk menambahkan satu elemen
dengan nilai X pada puncak suatu stack, sehingga posisi TOP(S) akan
bernilai X, penerapan operasi push pasa suatu stack S akan berakibat
overflow jika NOEL(S) dari stack tersebut telah bernilai maksimum.

4. Pop(Stack)
Operasi ini berfungsi untuk menghapus satu elemen dari stack S,
sehingga posisi NOEL(S) akan berkurang satu elemen, dan TOP(S)
akan berubah. Operasi pop dapat menyebabkan kondisi underflow jika
suatu stack S yang berada dalam kondisi minimum dikenakan operasi
pop.

c. Implementasi stack menggunakan python

Dalam kehidupan sehari-hari, terdapat banyak kejadian yang
mempunyai sifat seperti stack, salah satunya adalah cerita di bawah ini:

Perhatikan sebuah tumpukian piring disebuah warung makan. Piring-piring

tersebut tersusun rapat dari atas ke bawah (membentuk barisan berurutan).
Setiap kali ada pembeli datang, maka piring yang paling atas akan diambil
(menghapus elemen) yang berarti mengurangi jumlah piring dalam
tumpukan. Bila tumpukan itu sudah habis atau tinggal sedikit maka
pegawai warung akan menambahkan piring lain yang masih bersih
(menambah elemen) piring yang paling terakhir diletakkan pasti akan
terletak ditumpukan paling atas dan piring yang terletak paling atas d alam
 tumpukan itu pasti merupakan tumpukan piring yang terakhir kali
dimasukkan.

d. Aplikasi stack (contoh kasus yang menggunakan konsep stack dalam

penyelesaiannya)

Program untuk menampilkan kode pos (zip code) dari suatu negara
bagian dan kota dan semua inf ormasi tersebut dimasukkan ke dalam sebuah
tumpukan. Apabila tidak ada keterangan yang dimasukkan berarti tumpukan
kosong. Tekan q jika akan keluar.

//Program:stack2.cpp
#include
#include
#include
#include
#define MAX_CITY 30
#define MAX_STATE 30
#define MAX_ZIP 5
void main (void);
int is_empty (struct node *);
int push (struct node **);
int pop (struct node **);
void search (struct node **);
void free_nodes (struct node **pstack);
struct node {
char zip_code[MAX_ZIP+1];
char city[MAX_CITY];
char state[MAX_STATE];
struct node *link;
};
void main (void)
{
struct node *pstack = NULL;
int ok_so_far = 1, no_of_nodes = 0;
while (ok_so_far == 1) {
ok_so_far = push(&pstack);
if (ok_so_far == 1)
no_of_nodes ++;
else if(ok_so_far == 0) {
puts("\nAn unexpected error has occurred - terminating program");
exit(1); //Abort program
}
}
search (&pstack); //search linked list
free_nodes(&pstack); //release memory back to OS when done
}
int push(struct node **pstack)
{
struct node *new_ptr; //pointer for new struct
new_ptr = (struct node *) malloc(sizeof(struct node)); //memory for new node
if(new_ptr == (struct node *) NULL) //if malloc returns NULL
{
printf("ERROR! Unable to allocate memory - Abort\n");
free(new_ptr);
return (0); //return 0 so calling function knows an error occurred
}
else
{
printf("\n\nEnter %d digit zip code or 'q' to quit>>", MAX_ZIP);
gets(new_ptr->zip_code); //input zip code
new_ptr->zip_code[MAX_ZIP] = '\0'; //NULL to 6th char in zip_code
if (strcmp(new_ptr->zip_code, "q") != 0) {
printf("\nEnter a less than %d character state name>>\n",
MAX_STATE);
Modul 7 Struktur Data (Arie) - 7
gets(new_ptr->state); //input state
printf("\nEnter a less than %d character city name>>\n",
MAX_CITY);
gets(new_ptr->city); //input city
new_ptr->link = *pstack;
*pstack = new_ptr;
return (1); //return 1 so calling func will continue to loop
}
else return (2); //return 2 so calling func to stop looping
}
}
void search (struct node **pstack)
{
struct node *ptemp;
int test = 0;
char ch, find[6];
ptemp = *pstack;
printf("\n\nEnter %d digit zip code to search for \nor 'e' to print entire list>>",
MAX_ZIP);
gets(find); //input zip code
find[MAX_ZIP] = '\0'; //assign NULL to 6th char in find array
if (find[0] =='E' || find[0] =='e') //if user wants to view entire list
{
test = 1;
while (test != 0) //while stack is not empty print
test = pop (pstack); //info from stack and free nodes
}
else //otherwise search for zip code
{
while (test == 0 || ptemp != NULL) //while not found nor at the end of
list
{
if (strcmp(ptemp->zip_code, find) == 0)
{
test = 1;
printf("Zip Code: %s\n", ptemp->zip_code);
printf("State: %s\n", ptemp->state);
printf("City: %s\n\n", ptemp->city);
}
else if (ptemp == NULL)
{
printf("The zip code %s was not found.\n", find);
test = 1;
}
ptemp = ptemp->link;
}
puts ("\nType 'y' if you would you like to see the entire list");
puts ("or any other key to continue>>");
if (ch == 'y' || ch == 'Y')
{
test = 1;
while (test != 0)
test = pop (pstack);
}
}
}
Modul 7 Struktur Data (Arie) - 8
int pop (struct node **pstack)
{
struct node *temp;
if (is_empty(*pstack)== 1)
{
printf("\nStack is now empty");
return(0);
}
else
{
temp = *pstack;
printf("Zip Code: %s\n", temp->zip_code);
printf("State: %s\n", temp->state);
printf("City: %s\n\n", temp->city);
*pstack = (*pstack)->link;
free(temp);
return(1);
}
}
int is_empty (struct node *stack) //test if stack points to NULL
{
if (stack == NULL)
return(1); //if stack does point to NULL return 1 or true
return(0); //othrewise stack is not empty
}
void free_nodes (struct node **pstack)
{
struct node *temp; //temp pointer used for free()ing memory
while (*pstack != NULL)
{
temp = *pstack;
*pstack = (*pstack)->link;
free(temp); //release popped node's memory back to Operating System
}
}
e. Sumber/referensi
• https://kurniawandanie.blogspot.com/

• https://www.ismynr.xyz/2018/10/contoh-program-stack-c-penjelasan.html

• https://www.yudana.id/belajar-stack-dan-queue-dalam-struktur-data/

• https://strukdatfikupn.blogspot.com/2011/03/stack-tumpukan.html

2. Antrian Queue
Queue pada Struktur Data atau antrian adalah sekumpulan data yang
mana penambahan elemen hanya bisa dilakukan pada suatu ujung disebut
dengan sisibelakang(rear), dan penghapusan(pengambilan elemen) dilakukan
lewat ujung lain (disebut dengan sisi depan atau front).
Pada Stack atau tumpukan menggunakan prinsip“Masuk terakhir keluar
pertama”atau LIFO (Last In First Out), Maka pada Queue atau antrian prinsip
yang digunakan adalah “Masuk Pertama Keluar Pertama” atau FIFO (First In
First Out).
Queue atau antrian banyak kita jumpai dalam kehidupan sehari-hari, ex:
antrian Mobil diloket Tol, Antrian mahasiswa Mendaftar, dll.
Contoh lain dalam bidang komputer adalah pemakaian sistem komputer
berbagi waktu(time-sharing computer system) dimana ada sejumlah pemakai
yang akan menggunakan sistem tersebut secara serempak.
Pada Queue atau antrian Terdapat satu buah pintu masuk di suatu ujung dan
satu buah pintu keluar di ujung satunya dimana membutuhkan variabel Head
dan Tail ( depan/front, belakang/rear).

a. Konsep Queue
Queue adalah bentuk lain dari konsep implementasi linked list.
Berbeda dengan Stack, yang menerapkan konsep LIFO (Last In First
Out), Queue justru mempunyai konsep yang berbeda yakni FIFO (First In
First Out). Setiap data yang pertama kali masuk, dialah yang akan keluar
duluan. Contoh paling simple dalam kehidupan sehari hari adalah
antrian pengunjung bank. Biasanya saat masuk, kita akan diberi nomor
 antrian terlebih dahulu sebelum dipanggil oleh teller. Kita akan menunggu
sampai urutan kita barulah kita dapat bertransaksi di teller.

b. Operasi-operasi pada queue

Operasi-operasi Queue :
1. Create()
Untuk menciptakan dan menginisialisasi Queue Dengan cara membuat
Head dan Tail = -1

2. IsEmpty()
Untuk memeriksa apakah Antrian sudah penuh atau belumDengan cara
memeriksa nilai Tail, jika Tail = -1 maka empty
Kita tidak memeriksa Head, karena Head adalah tanda untuk kepala
antrian (elemen pertama dalam antrian) yang tidak akan berubah-ubah
Pergerakan pada Antrian terjadi dengan penambahan elemen Antrian
kebelakang, yaitu menggunakan nilai Tail.
3. IsFull
Untuk mengecek apakah Antrian sudah penuh atau belum Dengan cara
mengecek nilai Tail, jika Tail >= MAX-1 (karena MAX-1 adalah batas
elemen array pada C) berarti sudah penuh

4. Enqueue
Untuk menambahkan elemen ke dalam Antrian, penambahan elemen
selalu ditambahkan di elemen paling belakang Penambahan elemen
selalu menggerakan variabel Tail dengan cara increment counter Tail
terlebih dahulu
5. Dequeue()
Digunakan untuk menghapus elemen terdepan/pertama (head) dari
AntrianDengan cara menggeser semua elemen antrian kedepan dan
mengurangi Tail dgn Penggeseran dilakukan dengan menggunakan
looping.
 6. Clear()
Untuk menghapus elemen-elemen Antrian dengan cara mebuat Tail
dan Head = -1 Penghapusan elemen-elemen Antrian sebenarnya tidak
menghapus arraynya, namun hanya mengeset indeks pengaksesan-nya
ke nilai -1 sehingga elemen-elemen Antrian tidak lagi terbaca

7. Tampil()
Untuk menampilkan nilai-nilai elemen Antrian
Menggunakan looping dari head s/d tail

c. Implementasi Queue menggunakan python

Queue (Antrian) adalah kumpulan data yang berurut dimana
penambahan data baru berada di satu ujung bernama ekor atau rear.
Sedangkan penghapusan data berada di ujung kepala atau front. Queue
menggunakan metode pengurutan FIFO (First In, First Out) yaitu data
yang masuk pertama maka data tersebut juga keluar pertama kali. Contoh
implementasi dari Queue adalah Antrian sembako, permainan temukan
orang dan lain sebagainya.

d. Aplikasi Queue (contoh kasus menggunakan konsep Queue dalam

penyelesaiannya)
Berikut ini kode program dalam Pasien yang sedang antri pada sebuah
layanan :
from datetime import timedelta, datetime
from time import sleep

class Queue:
def __init__(self):
self.items=[]
def isEmpty(self):
return self.items == []
def enqueue(self,item):
self.items.insert(0,item)
def dequeue(self):
return self.items.pop()
def rear(self):
return self.items[0]
def front(self):
return self.items[len(self.items)-1]
def size(self):
return len(self.items)
def open(self):
return self.items

def antrian():
endtime = datetime.now() + timedelta(seconds = 2)
tanda='n'
m = Queue()
cad = Queue()
inputan = int(input('Masukan berapa orang yang ingin antri = '))
for i in range(inputan):
nama = input('Masukan nama costumer ke %i = '%(i+1))
m.enqueue(nama)
cad.enqueue(nama)

print("Estimasi Jam Pelayanan Customer")

while not m.isEmpty():
if not m.isEmpty():
if tanda=='n':
print(m.dequeue(),'akan dilayani pada :',datetime.now())
tanda='y'
else:
print(m.dequeue(),'akan dilayani pada :',endtime)
 endtime = endtime + timedelta(seconds = 2)

tanda='n'
print("=======================Antrian======================")
while not cad.isEmpty():
if not cad.isEmpty():
if tanda==0:
print(cad.dequeue(),'sedang dilayani')
tanda=1
else:
sleep(2)
print(cad.dequeue(),'sedang dilayani')

if cad.isEmpty():
print('===============Antrian Kosong==================')
antrian()

antrian()

e. Sumber/referensi
• https://baranghalusdev.blogspot.com/2017/04/queue-pada-python-
indonesian-language.html
• https://www.mahirkoding.com/struktur-data-queue-dan-
implementasinya/
• https://blog-arul.blogspot.com/2012/01/queue-pada-struktur-
data.html

3. Untaian Tunggal (Single Linked List)

Single Linked List merupakan sebuah tempat yang disediakan pada satu
area memori tertentu untuk menyimpan data yang dikenal dengan sebutan node
atau simpul. Setiap node memiliki pointer yang menunjuk ke simpul berikutnya
sehingga terbentuk satu untaian, dengan demikian hanya diperlukan sebuah
variabel pointer. Susunan berupa untaian semacam ini disebut Single Linked
List. Biasanya Linked List pada node terakhir akan menunjuk ke NULL,
dimana NULL memilik nilai khusus yang artinya tidak menunjuk ke mana-
mana.
Pembuatan Single Linked List dapat menggunakan 2 metode:
– LIFO (Last In First Out), aplikasinya : Stack (Tumpukan)
– FIFO (First In First Out), aplikasinya : Queue (Antrean)

a. Konsep Single Linked List

Single Linked List adalah sekumpulan dari node yang
saling terhubung dengan node lain melalui sebuah pointer. Single Linked
List hanya memiliki satu arah dan tidak memiliki dua arah atau bulak balik, dua
arah tersebut disebut dengan double linked list. Susunan berupa untaian
semacam ini disebut Single Linked List. Biasanya Linked List pada node
terakhir akan menunjuk ke NULL, dimana NULL memilik nilai khusus yang
artinya tidak menunjuk ke mana-mana.

b. Operasi-Operasi Pada Single Linked List

1. Insert = Menambahkan Sebuah Simpul baru KeDalam Linked List
2. Konstruktor = Fungsi ini membuat sebuah linked list yang baru dan
masih kosong.
3. IsEmpty = Fungsi ini menentukan apakah linked list kosong atau
tidak.
4. Find First = Fungsi ini mencari elemen pert ama dari linked list
5. Find Next = Fungsi ini mencari elemen sesudah elemen yang
ditunjuk now.
6. Retrieve = Fungsi ini mengambil elemen yang ditunjuk oleh now.
Elementersebut lalu dikembalikan oleh fungsi.
7. Update = Fungsi ini mengubah elemen yang ditunjuk oleh now
dengan isi dari sesuatu.
8. Delete Now = Fungsi ini menghapus elemen yang ditunj uk oleh
now. J ika yang dihapus adalah elemen pertama dari linked list
(head), head akan berpindah ke elemen berikut.

c. Implementasi Single Linked List menggunakan python

class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
def push(self, new_data):
new_node = Node(new_data)
 new_node.next = self.head
self.head = new_node
# List penjumlahan dua buah Nodes
def addTwoLists(self, first, second):
prev = None
temp = None
carry = 0
while (first is not None or second is not None):
fdata = 0 if first is None else first.data
sdata = 0 if second is None else second.data
Sum = carry + fdata + sdata
carry = 1 if Sum >= 10 else 0
Sum = Sum if Sum < 10 else Sum % 10
temp = Node(Sum)
if self.head is None:
self.head = temp
else:
prev.next = temp
prev = temp
if first is not None:
first = first.next
if second is not None:
second = second.next
if carry > 0:
temp.next = Node(carry)
def printList(self):
temp = self.head
while (temp):
print temp.data,
temp = temp.next
first = LinkedList()
second = LinkedList()
first.push(3)
first.push(4)
first.push(7)

print "\nSebagai contoh kita ingin Menjumlah : "

print "\n347 + 37 = ..."
print "\nUntuk semua list dilihat dari belakang"
print "\nList Pertama yaitu =",
first.printList() ,

second.push(3)
second.push(7)
print "\nList Kedua yaitu =",
second.printList()," "
 res = LinkedList()
res.addTwoLists(first.head, second.head)
print "\nPenjumlahan Kedua List =",
res.printList()

d. Aplikasi Single Linked List (contoh kasus yang menggunakan konsep

Single Linked List dalam penyelesaiannya)
//SINGLE LINKED LIST NON CIRCULAR
//IDE VS12 Express
//by [RS]
#include <iostream>
#include <conio.h>
#include <iomanip> //setw()
using namespace std;

struct node
{
int data;
node* next; // untuk menghubungkan dengan node lain,
tipe data dibuat sama seperi aturan penggunaan pointer.
};

node* head;
node* tail;
node* curr;
node* entry;
node* del;

void inisialisasi()
{
head = NULL;
tail = NULL;
}

void input(int dt)

{
entry = (node* )malloc(sizeof(node)); //alokasi
memori
entry->data = dt;
entry->next = NULL;
if(head==NULL)
 {
head = entry;
tail = head;
}
else
{
tail->next = entry;
tail = entry;
}
}

void hapus()
{
int simpan;
if(head==NULL)
{
cout<<"\nlinked list kosong, penghapusan tidak
bisadilakukan"<<endl;
}
else
{
simpan = head ->data;
//hapus depan
del = head;
head = head->next;
delete del;

cout<<"\ndata yang dihapus adalah

"<<simpan<<endl;
}

void cetak()
{
curr = head;
if(head == NULL)
cout<<"\ntidak ada data dalam linked
list"<<endl;
else
{
 cout<<"\nData yang ada dalam linked list
adalah"<<endl;
cout<<setw(6);
while(curr!=NULL)
{
cout<<curr->data<<"->";
curr = curr->next;
}
cout<<"NULL";
cout<<endl;
}
}

void menu()
{
char pilih, ulang;
int data;

do
{
system("cls");
cout<<"SINGLE LINKED LIST NON CIRCULAR"<<endl;
cout<<"-------------------------------"<<endl;
cout<<"Menu : "<<endl;
cout<<"1. Input data"<<endl;
cout<<"2. Hapus data"<<endl;
cout<<"3. Cetak Data"<<endl;
cout<<"4. Exit"<<endl;
cout<<"Masukkan pilihan Anda : ";
cin>>pilih;

switch(pilih)
{
case '1' :
cout<<"\nMasukkan data : ";
cin>>data;
input(data);
break;
case '2' :
hapus();
break;
case '3' :
 cetak();
break;
case '4' :
exit(0);
break;
default :
cout<<"\nPilih ulang"<<endl;
}
cout<<"\nKembali ke menu?(y/n)";
cin>>ulang;
}while(ulang=='y' || ulang=='Y');
}

int main()
{

inisialisasi();
menu();

return EXIT_SUCCESS;
}

Output

Input data (2,3,4,5,6)

SINGLE LINKED LIST NON CIRCULAR
-------------------------------
Menu :
1. Input data
2. Hapus data
3. Cetak Data
4. Exit
Masukkan pilihan Anda : 1

Masukkan data : 2

Kembali ke menu?(y/n)
SINGLE LINKED LIST NON CIRCULAR
-------------------------------
Menu :
1. Input data
2. Hapus data
3. Cetak Data
4. Exit
Masukkan pilihan Anda : 1

Masukkan data : 3

Kembali ke menu?(y/n)
SINGLE LINKED LIST NON CIRCULAR
-------------------------------
Menu :
1. Input data
2. Hapus data
3. Cetak Data
4. Exit
Masukkan pilihan Anda : 1

Masukkan data : 4

Kembali ke menu?(y/n)
SINGLE LINKED LIST NON CIRCULAR
-------------------------------
Menu :
1. Input data
2. Hapus data
3. Cetak Data
4. Exit
Masukkan pilihan Anda : 1

Masukkan data : 5

Kembali ke menu?(y/n)
SINGLE LINKED LIST NON CIRCULAR
-------------------------------
Menu :
1. Input data
2. Hapus data
3. Cetak Data
4. Exit
Masukkan pilihan Anda : 1

Masukkan data : 6
 Kembali ke menu?(y/n)

Hapus data
SINGLE LINKED LIST NON CIRCULAR
-------------------------------
Menu :
1. Input data
2. Hapus data
3. Cetak Data
4. Exit
Masukkan pilihan Anda : 2

data yang dihapus adalah 2

Kembali ke menu?(y/n)

Ceak data
SINGLE LINKED LIST NON CIRCULAR
-------------------------------
Menu :
1. Input data
2. Hapus data
3. Cetak Data
4. Exit
Masukkan pilihan Anda : 3

Data yang ada dalam linked list adalah

3->4->5->6->NULL

Kembali ke menu?(y/n)

e. Sumber/Referensi

• https://www.coursehero.com/file/49673220/Operasi-Pada-Single-Linked-
Listdocx/#:~:text=html%20Operasi%20Pada%20Single%20Linked%20List%
201.%20Insert%20%3D%20Istilah%20Insert,linked%20list%20kosong%20at
au%20tidak.
• https://irvandimetrio21.home.blog/2019/07/23/program-penambahan-
list-dengan-linked-list-di-python/
• http://www.nblognlife.com/2014/12/single-linked-list-pada-c.html
4. Pohon biner (binary tree)
Merupakan salat Satu bentuk Struktur Data tidak linier Yang
menggambarkan hubungan Yang bersifat hirarkis (hubungan one to many)
antara elemen-elemen. Tree Bisa 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).

a. Konsep Dasar Pohon Biner

Tree/pohon merupakan struktur data yang tidak linear/non linear yang
digunakan terutama untuk merepresentasikan hubungan data yang bersifat
hierarkis antara elemen-elemennya. Kumpulan elemen yang salah satu
elemennya disebut dengan root (akar) dan sisa elemen yang lain disebut
sebagai simpul (node/vertex) yang terpecah menjadi sejumlah himpunan yang
tidak saling berhubungan satu sama lain, yang disebut subtree/cabang.
Sebuah pohon biner T dapat didefinisikan sebagai sekumpulan terbatas
dari elemen-elemen yang disebut nodes/simpul dimana :
T dikatakan kosong (disebut null tree/pohon null atau empty tree/pohon
kosong)
T terdiri dari sebuah node khusus yang dipanggil R, disebut root dari T dan
node-node T lainnya membentuk sebuah pasangan terurut dari binary tree T1
dan T2 yang tidak berhubungan yang kemudian dipanggil subtree kiri dan
subtree kanan.
Jika T1 tidak kosong maka rootnya disebut successor kiri dari R dan jika T2
tidak kosong, maka rootnya disebut successor dari R.

b. Operasi-operasi pada Binary Tree :

• Create : Membentuk binary tree baru yang masih kosong.

• Clear : Mengosongkan binary tree yang sudah ada.
• Empty : Function untuk memeriksa apakah binary tree masih kosong.
• Insert : Memasukkan sebuah node ke dalam tree. Ada tiga pilihan
insert: sebagai root, left child, atau right child. Khusus insert sebagai
root, tree harus dalam keadaan kosong.
• Find : Mencari root, parent, left child, atau right child dari suatu node.
(Tree tak boleh kosong)
 • Update : Mengubah isi dari node yang ditunjuk oleh pointer current.
(Tree tidak boleh kosong)
• Retrieve : Mengetahui isi dari node yang ditunjuk pointer current.
(Tree tidak boleh kosong)
• DeleteSub : Menghapus sebuah subtree (node beserta seluruh
descendantnya) yang ditunjuk current. Tree tak boleh kosong. Setelah
itu pointer current akan berpindah ke parent dari node yang dihapus.
• Characteristic : Mengetahui karakteristik dari suatu tree, yakni : size,
height, serta average lengthnya. Tree tidak boleh kosong. (Average
Length =
[jumlahNodeLvl1*1+jmlNodeLvl2*2+…+jmlNodeLvln*n]/Size)
• Traverse : Mengunjungi seluruh node-node pada tree, masing-masing
sekali. Hasilnya adalah urutan informasi secara linier yang tersimpan
dalam tree. Ada tiga cara traverse : Pre Order, In Order, dan Post
Order.

c. Implementasi Binary Tree Di Phyton

from __future__ import print_function

class Stack:
def __init__(self):
self.items = []

def isEmpty(self):
return self.items==[]

def push(self,items):
self.items.append(items)

def pop(self):
return self.items.pop()
 def peek(self):
return self.items[len(self.items)-1]

def size(self):
return len(self.items)

class Binarytree:
def __init__(self,root):
self.key = root
self.leftChild = None
self.rightChild = None

def insertLeft(self,newNode):
if self.leftChild == None :
self.leftChild = Binarytree(newNode)

else :
t = Binarytree(newNode)
t.leftChild = self.leftChild
self.leftChild = t

def insertRight(self,newNode):
if self.rightChild == None :
self.rightChild = Binarytree(newNode)

else :
t = Binarytree(newNode)
t.rightChild = self.rightChild
 self.rightChild = t

def getrightChild(self):
return self.rightChild

def getleftChild(self):
return self.leftChild

def getrootVal(self):
return self.key

def setrootVal(self,obj):
self.key = obj

def size(self):
count = 0
selfleft = self
selfright = self
while selfleft.getleftChild() != None or selfright.getrightChild() !=
None :
count += 1
if selfleft.getleftChild() != None:
selfleft = selfleft.getleftChild()
else :
selfright = selfright.getrightChild()
return count

def Inorder(root):
 if root:
Inorder(root.getleftChild())
print(root.getrootVal(),end=" ")
Inorder(root.getrightChild())

def Preorder(root):
if root:
print(root.getrootVal(),end=" ")
Preorder(root.getleftChild())
Preorder(root.getrightChild())

def Postorder(root):
if root:
Postorder(root.getleftChild())
Postorder(root.getrightChild())
print(root.getrootVal(),end=" ")

root = Binarytree('P')
root.insertLeft('F')
root.getleftChild().insertLeft('B')
root.getleftChild().insertRight('H')
root.getleftChild().getleftChild().insertLeft('A')
root.getleftChild().getrightChild().insertRight('M')
root.insertRight('S')
root.getrightChild().insertLeft("R")
root.getrightChild().insertRight("W")

Inorder(root)
 print ()
Preorder(root)
print ()
Postorder(root)

d. Aplikasi Binary Tree

Binary Search Tree(BST)
Mengapa BST cocok untuk pengolahan database?Karena struktur datanya
yang begitu unik dan rapi, BST bisa digunakan sebagai alternatif dalam
database.Kemudian seperti yang telah dibicarakan pada babsebelumnya,
BST memiliki fitur-fitur yang dapatdigunakan dalam database seperti
Insert Element, DeleteElement, Search Element, Display Element. Selain
ituBST juga bisa melakukan penghitungan jumlah totalelemen yang ada
di dalam database. Prinsip penghitunganini dapat dilakukan dengan
prinsip penghitungan jumlahnode yang ada pada BST tersebut. Kalkulasi
elemen bilangan bulat atau real nya pun dapat dilakukan denganmudah
dengan menggunakan BST. Karena BST memilikisifat perbandingan
lebih besar dan lebih kecil, maka key pada database yang dibentuk dari
BST haruslah unik. Halini memang sesuai dengan dunia nyata di mana
sebuah NIM merepresentasikan hanya satu mahasiswa, NIPhanya
mewakili seorang pegawai di sebuah pabrik, satu NO KTP hanyalah
untuk seorang warga Negara dan tidak bisa lebih.Keunggulan BST
sebagai database juga karenaefisiensi memorinya. Maksud dari efisiensi
memori di siniadalah karena sifat dari BST adalah dinamik, di mana
jumlah memori fleksibel sesuai dengan jumlah elemenyang ada. BST juga
dapat dibentuk menjadi sebuahmultilist yang mampu mengakses elemen
record lainnyalayaknya multilist pada umumnya. Namun ada kekurangan
BST sebagai alternatif pengolahan database. Kelemahan tersebut adalah
tidaksemua elemennya terkait ke elemen lainnya. Misalkankita berada di
elemen di mana node tersebut adalah salahsatu daun dari BST, kita tidak
bisa langsungpergi keelemen di upapohon lainnya. Selain itu, kita tidak
bisasecara langsung memanggil sebuah indeks tabel untukmemanggil
node tertentu, jika kita bandingkan denganrepresentasi tabel. Namun
sebenarnya hal tersebut tidakterlalu berpengaruh karena pengaksesan
suatu nilai dari pengguna tentunya selalu ketika pointer berada di
nodeawal dan penampilan semua node tidak harus dengan carademikian
dan kita tidak selalu membutuhkan indeks tabeluntuk mencari
e. Sumber/referensi

• (Https://Wikipedia.org)
• (https://www.google.com/amp/s/dimasandree.wordpress.com/2013/12/
18/konsep-dasar-stack-dan-binary-tree/amp/)
• (https://www.google.com/amp/s/saragusti22.wordpress.com/2015/05/0
4/pengantar-struktur-data-tree-dan-binary-tree/amp/)
• (Https://academia.edu)
• (http://fitrianisaa25.blogspot.com/2018/06/tree-1.html?m=1)
• https://www.google.com/amp/s/dimasandree.wordpress.com/2013/12/1
8/konsep-dasar-stack-dan-binary-tree/amp/)
• (https://www.academia.edu/9114596/Penerapan_Teknik_Binary_Searc
h_Tree_Sebagai_Alternatif_Penyimpanan_Data)
• https://www.google.com/amp/s/saragusti22.wordpress.com/2015/05/04
/pengantar-struktur-data-tree-dan-binary-tree/amp/)