Heaps And Tries

HEAP

Heap adalah struktur data berbasis pohon khusus di mana pohon itu adalah pohon biner lengkap. Secara umum, tumpukan dapat terdiri dari dua jenis:

• Max-Heap: Dalam Max-Heap kunci yang ada di simpul akar harus paling besar di antara kunci yang ada di semua anak-anak itu. Properti yang sama harus benar secara rekursif untuk semua sub-pohon di Pohon Biner itu.
• Min-Heap: Dalam Min-Heap kunci yang ada di simpul akar harus minimum di antara kunci yang ada di semua anak-anak itu. Properti yang sama harus benar secara rekursif untuk semua sub-pohon di Pohon Biner itu.

 TRIES

Trie adalah struktur data mirip pohon yang simpulnya menyimpan huruf-huruf alfabet. 

Dengan menyusun simpul dengan cara tertentu, kata dan string dapat diambil dari struktur 

dengan melintasi jalur cabang pohon.

Dreamer's Market Source Code

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <windows.h>
#include <string.h>
#include <conio.h>
struct node {
char item[30];
long long int price;
long long int quantity;
long long int totalPrice;
struct node *next;
struct node *prev;
};

long long int borderLength;
long long int spasiHeader;
long long int spasiNama;
long long int spasiQuantity;
long long int spasiPrice;
long long int spasiNumber;
long long int spasiTotalPrice;
node *head;
node *tail;

void gotoxy(int x, int y){
COORD coord;
coord.X = x;
coord.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
}
void setup(){
head = NULL;
tail = NULL;
borderLength = 0;
spasiNama = 30;
spasiQuantity = 0;
borderLength = 0;
spasiPrice = 0;
spasiTotalPrice = 0;
}
long long int numLength(long long int input){
long long int remainder = 0;
long long int length =0;
while(input>0){
remainder = input % 10;
input = (input-remainder)/10;
length++;
}
return length;
}
void spaceCounter(){
node *curr = head;
long long int length = 0;
long long int temp =0;
while(curr!=NULL){
temp = curr->quantity;
if(spasiQuantity < numLength(temp)){
spasiQuantity = numLength(temp);
}
temp = curr->price;
if(spasiPrice<numLength(temp)){
spasiPrice = numLength(temp);
}
temp = curr->totalPrice;
if(spasiTotalPrice < numLength(temp)){
spasiTotalPrice = numLength(temp);
}
length++;
curr = curr->next;
}
spasiNumber = numLength(length);
}
int DisplayMenu(){
int choice;
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
printf("             Welcome to Dreamers Market\n");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
printf("\tplease select your input\n");
printf("\t 1. Add Item to Cart\n");
printf("\t 2. Edit Item in Cart\n");
printf("\t 3. Remove Item from Cart\n");
printf("\t 4. Checkout\n");
printf("\t Input >> ");
scanf("%d", &choice);getchar();

return choice;
}
int displayList(){
long long int i;
node *curr = head;
if(curr == NULL){
printf("===================================================\n");
printf("|                 No Item in Cart                 |\n");
printf("===================================================\n");
return 0;
}else{
spaceCounter();
borderLength = 15+ spasiNama + spasiNumber + spasiQuantity + spasiPrice;
spasiHeader = borderLength - 24;
for(i = 0; i<borderLength; i++){
printf("=");
}
printf("\n| List of items in Cart");
for(i = 0; i<spasiHeader; i++){
printf(" ");
}
printf("|\n");
for(i = 0; i<borderLength; i++){
printf("=");
}
printf("\n");
i=1;
while(curr != NULL){
long long int j;
printf("| ");
for(j = 0; j<spasiNumber-numLength(i); j++){
printf("0");
}
printf("%lld | ", i);
for(j = 0; j<spasiNama-strlen(curr->item); j++){
printf(" ");
}
printf("%s | %lld", curr->item, curr->quantity);
for(j = 0; j<spasiQuantity-numLength(curr->quantity); j++){
printf(" ");
}
printf(" | Rp");
for(j = 0; j<spasiPrice-numLength(curr->price); j++){
printf(" ");
}
printf("%lld |\n", curr->price);
curr = curr->next;
i++;
}
return 1;
}
}
void insertNode(char innputName[], long long int inputQty, long long int priceInput){
node *temp = (node*)malloc(sizeof(struct node));
strcpy(temp->item, innputName);
temp->price = priceInput;
temp->quantity = inputQty;
temp->totalPrice = inputQty * priceInput;

if(head == NULL){
head = temp;
tail = temp;
temp->next = NULL;
temp->prev = NULL;
}else{
if(strcmp(temp->item, head->item) == -1 || strcmp(temp->item, head->item) == 0){
temp->next = head;
temp->prev = NULL;
head->prev = temp;
head = temp;
return;
}else if(strcmp(temp->item, tail->item) == 1 || strcmp(temp->item, tail->item) == 0){
temp->prev = tail;
temp->next = NULL;
tail->next = temp;
tail = temp;
return;
}else{
node *currNode = head;
node *prevNode = NULL;
while(strcmp(temp->item, currNode->item) == 1 && currNode->next != NULL){
currNode = currNode->next;
}
temp->next = currNode;
temp->prev = currNode->prev;
currNode->prev = temp;
temp->prev->next = temp;
}
}
}
void displayBill(){
node *curr = head;
long long int x;
long long int y;
long long int sum = 0;
long long int i;
long long int spasiSum = 0;
spaceCounter();
borderLength = 20 + spasiNama + spasiTotalPrice + spasiQuantity + spasiPrice;
if(curr == NULL){
printf("==================================================\n");
printf("|                Dreamer's Market                |\n");
printf("==================================================\n");
printf("==================================================\n");
printf("| Price :                                   RP 0 |\n");
printf("| Discount :                              - RP 0 |\n");
printf("| Total :                                   RP 0 |\n");
printf("==================================================\n");
printf("|                Kindness is Free                |\n");
printf("==================================================\n");
return;
}
for(i = 0; i<borderLength; i++){
printf("=");
}
printf("\n");
x = (borderLength - 18)/2;
printf("|");
for(i = 0; i<x; i++){
printf(" ");
}
printf("Dreamer's Market");
y = borderLength-x-18;
for(i = 0; i<y; i++){
printf(" ");
}
printf("|\n");
for(i = 0; i<borderLength; i++){
printf("=");
}
printf("\n");
while(curr != NULL){
printf("| ");
for(i = 0; i<spasiQuantity-numLength(curr->quantity); i++){
printf(" ");
}
printf("%lld | ", curr->quantity);
for(i = 0; i<spasiNama-strlen(curr->item); i++){
printf(" ");
}
printf(" %s | Rp ", curr->item);
for(i = 0; i<spasiPrice-numLength(curr->price); i++){
printf(" ");
}
printf("%lld | Rp ", curr->price);
for(i = 0; i<spasiTotalPrice-numLength(curr->totalPrice); i++){
printf(" ");
}
printf("%lld |\n", curr->totalPrice);
sum = sum + curr->totalPrice;
curr = curr->next;
i++;
}
for(i = 0; i<borderLength; i++){
printf("=");
}
printf("\n");
printf("| Price :");
for(i = 0; i<borderLength-numLength(sum)-14; i++){
printf(" ");
}
printf("RP %lld |\n", sum);
printf("| Discount :");
for(i = 0; i<borderLength-numLength(sum)-19; i++){
printf(" ");
}
printf("- RP %lld |\n", sum);
printf("| Total :");
sum = 0;
for(i = 0; i<borderLength-15; i++){
printf(" ");
}
printf("RP 0 |\n");
for(i = 0; i<borderLength; i++){
printf("=");
}
printf("\n");
x = (borderLength - 18)/2;
printf("|");
for(i = 0; i<x; i++){
printf(" ");
}
printf("Kindness is Free");
y = borderLength-x-18;
for(i = 0; i<y; i++){
printf(" ");
}
printf("|\n");
for(i = 0; i<borderLength; i++){
printf("=");
}
printf("\n");
}
void remove(struct node* del){
if (head == NULL || del == NULL)
return;

if (head== del)
head = del->next;

if (del->next != NULL)
del->next->prev = del->prev;

if (del->prev != NULL)
del->prev->next = del->next;

free(del);
}

int isExistEdit(char input[]){
char inputName[100];
long long int inputQuantity;
long long int inputPrice;
node *curr = head;
while(curr!=NULL){
if(strcmp(curr->item, input)==0){
inputPrice = curr->price;
do{
printf("\tInput new item Name [1-30 charracter]\n");
printf("\t =>");
scanf("%[^\n]", inputName);getchar();
}while(strlen(inputName)>30 || strlen(inputName)<1);
printf("\t Input new item quantity =>");
scanf("%lld", &inputQuantity);getchar();
remove(curr);
insertNode(inputName, inputQuantity, inputPrice);
return 1;
}
curr = curr->next;
}
printf("\t~ Item Not Found Input Again ~\n");
return 0;
}

int isExistRemove(char input[]){
char inputName[100];
long long int inputQuantity;
long long int inputPrice;
node *curr = head;
while(curr!=NULL){
if(strcmp(curr->item, input)==0){
remove(curr);
return 1;
}
curr = curr->next;
}
printf("\t~ Item Not Found Input Again ~\n");
return 0;
}


int main(){
int choice;
char inputName[100];
long long int inputQty;
long long int priceInput;
setup();
while(true){
system("cls");
gotoxy(0, 10);
displayList();
gotoxy(0, 0);
choice = DisplayMenu();
if(choice == 1){
do{
system("cls");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
printf("             Welcome to Dreamers Market\n");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n");
printf("\tInput Item's Name [1-30 charracter]=> ");
scanf("%[^\n]", inputName);getchar();
}while(strlen(inputName)>30 || strlen(inputName)<1);
printf("\tInput Item's Quantity => ");
scanf("%lld", &inputQty);getchar();
priceInput = (rand()%100+1)*100;
insertNode(inputName, inputQty, priceInput);

}else if(choice == 2){
system("cls");
int option = displayList();
if(option == 1){
do{
printf("\tInput item name that you want to edit\n");
printf("\tItem name => ");
scanf("%[^\n]", inputName); getchar();
}while(isExistEdit(inputName)==0);
}else{
system("cls");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
printf("             Welcome to Dreamers Market\n");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n");
printf("\tThere are no existing item in cart\n");
printf("\tPlease add item if you want to edit\n");
printf("\n\tPress any key to go back...");
char c = getch();
}


}else if(choice == 3){
system("cls");
int option = displayList();
if(option == 1){
do{
printf("\tInput item name that you want to delete\n");
printf("\tItem name => ");
scanf("%[^\n]", inputName); getchar();
}while(isExistRemove(inputName)==0);
}else{
system("cls");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
printf("             Welcome to Dreamers Market\n");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n");
printf("\tThere are no existing item in cart\n");
printf("\tPlease add item if you want to edit\n");
printf("\n\tPress any key to go back...");
char c = getch();
}


}else if(choice == 4){
system("cls");
displayBill();
break;
}
}
}

Summary sebelum UTS

Summary Linked List

by William Kurnia Mulyadi Putra/2301887521

1. Pengenalan Linked List

   Berdasrkan yang telah saya pelajari saya dapat menyimpulkan bahwa linked list suatu metode yang digunakan untuk menggantikan array agar menjadi lebih hemat memory. Linked list pada bahasa C dapat dibuat menggunakan struct{};

2. Perbedaan Linked List dengan Array

    keunggulan linked list dengan array :

·                     Linked list merupakan dynamic programming, artinya memory yang diperlukan sesuai dengan yang digunakan, sehingga linked list lebih hemat memory. 

·                     Memory yang diperlukan dapat dialokasikan pada saat program sedang berjalan, sedangkan memory yang diperlukan oleh array perlu dialokasikan sebelum program dicompile.

    kelemahan linked list terhadap array :

·                     kita tidak dapat melakukan random access pada saat menggunakan linked list, misanya :

tertdapat program :

#include <stdio.h>

int main (){

     int array[5] = {1,2,3,4,5};

//jika ingin mengubah array pada index kedua maka dapat dilakukan random //acces

Array[2] = 0;

//sehingga anggota array berubah menjadi {1,2,0,4,5};

         

   Tetapi dalam menggunakan linked list, kita harus mengkases anggota dimulai dari anggota terawal dan mengkases satu demi satu sampai mendapatkan anggota tujuan.

3. Cara Membuat Linked List Menggunakan Bahasa C

   Dalam bahasa C linked list dibuat dengan cara membuat sebuah struct{}; . Pada umumnya struktur linked list terdiri atas dua :

-         data yang disimpan linked list

-         pointer ke listnode selanjutnya

dalam bentuk kode ;

#include <stdio.h>

struct node {

   //data node

   node *next_node;

};

Setiap individu struct pada suatu linked list dinamakan node. Node terdepan pada suatu linked list diberikan nama head, sedangkan node terbelakang pada suatu linked list dinamakan tail. Hal – hal yang dapat dilakukan pada suatu linked list adalah menambahkan data dan menghapus data.

Cara memasukkan data di linked list terbagi menjadi 3 cara :

-         memasukkan data pada awal linked list

sebagai contoh, terdapat kode seperti berikut :

#include<stdio.h>

struct node {

          int data;

          node *next;

};

int main (){

int input;

          struct node *head = NULL;

          struct node *tail  = NULL;

         

printf("Inset data ==> ");

          scanf("%d", &input);getchar();

push_head(&head, input, &tail);

          return 0;

}

Maka untuk melakukan penambahan data pada head linked list :

void push_head (struct node **head, int value, struct node **tail){

          node *temp = (node*)malloc(sizeof(struct node));

          temp->data = value;

          if(*head == NULL){

                   temp->next = NULL;

                   *head = temp;

                   *tail = temp;

          }else{

                   temp->next = *head;

                   *head = temp;

          }

         

}

-         memasukkan data pada akhir linked list

sebagai contoh, terdapat kode seperti berikut :

#include<stdio.h>

struct node {

          int data;

          node *next;

};

int main (){

int input;

          struct node *head = NULL;

          struct node *tail  = NULL;

         

printf("Inset data ==> ");

scanf("%d", &input);getchar();

push_tail(&head, input, &tail);

          return 0;

}

Maka untuk melakukan penambahan data pada tail linked list :

void push_tail(struct node **head, int value, struct node **tail){

          node *temp = (node*)malloc(sizeof(struct node));

          temp->data = value;

          if(*head == NULL){

                   temp->next = NULL;

                   *head = temp;

                   *tail = temp;

          }else{

                   node *prev =  *tail;

                   temp->next = NULL;

                   prev->next = temp;

                   *tail = temp;

          }       

}

Cara menghapus data pada suatu linked list :

Sebagai contoh, terdapat kode seperti berikut :

#include<stdio.h>

struct node {

          int data;

          node *next;

};

Terdapat linked list berisis 1à2à3à4à5àNULL.

Maka kode untuk menampilkan isi linked list pada console adalah :

void display(struct node *current){

          if(current == NULL){

                   printf("Empty list\n");

          }else{

                   while(current!=NULL){

                             printf("%d-->", current->data);

                             current = current->next;

                   }

                   printf("[NULL]\n");

          }

         

}

Maka output yang ditampilkan pada console adalah :

1-->2-->3-->4-->5-->[NULL]

4. Jenis-Jenis Linked List

terdapat 4 jenis linked list yaitu :

- singly linked list -> merupakan linked list dimana setiap node hanya terhubung dengan node selanjutnya dan node terakhir memiliki pointer NULL.

- doubly linked list -> merupakan linked list dimana setiap node hanya terhubung dengan node selanjutnya dan node sebelumnya. Node terakhir memiliki pointer NULL.

-circular linked list -> merupakan linked list dimana setiap node hanya terhubung dengan node selanjutnya dan node terakhir memiliki pointer yang menunjuk ke node pertama.

-circular doubly linked list -> merupakan linked list dimana setiap node hanya terhubung dengan node selanjutnya dan node sebelumnya. Node terakhir memiliki pointer yang menunjuk ke node pertama.

Summary Stack and Queue

Stack merupakan jenis data structure yang menyimpan data secara linear dengan penerapan konsep LIFO (Last In First Out), artinya data yang terkahir masuk merupakan data yang pertama kali dikeluarkan. Stack dapat diibaratkan dengan tumpukan piring dimana piring yang terakhir kali ditambahkan merupakan piring yang pertama kali diambil dari tumpukan tersebut. Implementasi stack dapat berupa linked list, array of struct, atau array. Jenis operasi yang dapat dilakukan pada suatu stack :
- pop (menghapus data paling terakhir ditambahkan)
- push (menambahkan data kedalam stack)

Queue merupakan jenis data structure yang menyimpan data secara linear dengan penerapan konsep FIFO (First In First Out), artinya data yang pertama dimasukkan merupakan data yang terakhir kali dikeluarkan. Queue dapat diibaratkan seperti sebuah antrian. Orang yang pertama kali masuk ke dalam antrian merupakan orang yang pertama keluar dari antrian tersebut. Implementasi queue dapat berupa linked list, array of struct, atau array. Jenis operasi yang dapat dilakukan pada suatu queue :
- pop (menghapus data paling pertama ditambahkan)
- push (menambahkan data pada akhir queue)

Hash Table dan Binary Tree

1. Hash table

hash table adalah salah satu jenis struktur data yang menerapkan konsep penggunaan suatu fungsi
sebagai pemetaan nilai kunci yang unik dari value suatu data menjadi suatu indeks yang merupakan lokasi dari data tersebut. Hash table digunakan untuk mempercepat proses akses data. Contohnya, bila terdapat data yang ingin di simpan dalan suatu array :
data :
- Andre # 15
- William # 28
- Mona # 20
dan data tersebut dibuatkan hash function f(x) = (jumlah ASCII nama)%10, dimana x merupakan string nama. maka Mona yang berumur 20 akan disimpan didalam array dengan indeks bernomor 5.
sehingga jika ingin dilakukan akses data mona maka tidak perlu dilakukan lienar search dan dapat langsung mengakses array indeks kelima.

fungsi hash pada blockchain digunakan dalam kriptografi. hasing sangat cepat dan tepat sehingga sangat ideal untuk kriptografi dan masih digunakan sampai sekarang.

kode untuk menyimpan :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

struct node{
 int age;
 char name[100];
 node *next;
};

struct hash{
 node *head;
 node *tail;
};

int getIndex(char input[]){
 int sum = 0;
 for(int i=0; input[i]!='\0'; i++){
  sum = sum + input[i];
 }
 sum = sum%10;
 return sum;
}

void push(node **head, node **tail, int umur, char nama[]){
 node *temp = (node*)malloc(sizeof(struct node));
 strcpy(temp->name, nama);
 temp->age = umur;
 if(*head == NULL){
  *head = temp;
  *tail = temp;
 }else{
  (*tail)->next = temp;
  *tail = temp;
 }
 (*tail)->next = NULL;
}

void displayList(struct node *curr){
 while(curr!=NULL){
  printf("%s#%d-->", curr->name, curr->age);
  curr = curr->next;
 }
 printf("NULL\n");
 return;
}

int main(){
 int umur;
 char nama[100];
 hash array_hash[10];
 //initialize all head ans tail = NULL;
 for(int i=0; i<10; i++){
  array_hash[i].head = NULL;
  array_hash[i].tail = NULL;
 }
 
 do{
  system("cls");
  for(int i=0; i<10; i++){
   printf("%d| ", i);
   displayList(array_hash[i].head);
  }
  printf("\n");
  
  printf("insert nama ==> ");
  scanf("%[^\n]", nama);getchar();
  printf("insert umur ==> ");
  scanf("%d", &umur);getchar();
  int index = getIndex(nama);
  printf("masuk index %d\n", index);
  push(&array_hash[index].head, &array_hash[index].tail, umur, nama);
  
  //displaying array_hash content
  
   
 }while(true);
 
}




2. Binary Tree

binary tree atau pohon biner merupakan jenis struktur data yang menimpan data dalam bentuk hirearki. Setiap data dinamakan node, setiap node memiliki anak cabang kiri dan anak cabang kanan. Node paling pertama dinamakan Root dan node paling terakhir dinamakan Leaf. Operasi yang dapat dilakukan dalam suatu pohon biner adalah :
- insert : memasukknan data pada cabang kosong
- remove : menghapus suatu cabang tertentu
- create : membuat cabang baru

Summary Binary Search Tree

Binary Search Tree  adalah struktur data pohon biner berbasis simpul yang memiliki properti berikut:

·                              Subtree kiri dari sebuah node hanya berisi node dengan kunci lebih rendah dari kunci node.

·                              Subtree kanan sebuah node hanya berisi node dengan kunci lebih besar dari kunci node.

·                              Subtree kiri dan kanan masing-masing juga harus berupa pohon pencarian biner.

Cara mengubah array menjadi binary search tree :

#include<stdio.h>

#include<stdlib.h>

struct TNode

{

    int data;

    struct TNode* left;

    struct TNode* right;

};

struct TNode* newNode(int data);

struct TNode* sortedArrayToBST(int arr[], int start, int end)

{

    /* Base Case */

    if (start > end)

      return NULL;

    int mid = (start + end)/2;

    struct TNode *root = newNode(arr[mid]);

    root->left =  sortedArrayToBST(arr, start, mid-1);

    root->right = sortedArrayToBST(arr, mid+1, end);

    return root;

}

struct TNode* newNode(int data)

{

    struct TNode* node = (struct TNode*)

                         malloc(sizeof(struct TNode));

    node->data = data;

    node->left = NULL;

    node->right = NULL;

    return node;

}

void preOrder(struct TNode* node)

{

    if (node == NULL)

        return;

    printf("%d ", node->data);

    preOrder(node->left);

    preOrder(node->right);

}

int main()

{

    int arr[] = {1, 2, 3, 4, 5, 6, 7};

    int n = sizeof(arr)/sizeof(arr[0]);

    struct TNode *root = sortedArrayToBST(arr, 0, n-1);

    printf("PreOrder Traversal of constructed BST ");

    preOrder(root);

    return 0;

}

Operasi yang dapat dilakukan dalam binary serach tree :

·                     -         Insert  => memasukkan data kedalam binary search tree

·                     -          Delete => menghapus node data dari binary tree

·                     -          Search => mencari data tersebut

·                     -          Print  => memperlihatkan data yang sudah disimpan

Apakah kegunaan binary search tree ?

Untuk mempermudah mengakses dan menyimpan data. Contohnya :

Ok, langsung saja kecontohnya. Misal kita memiliki urutan angka yang dimasukkan kedalam data dengan urutan sebagai berikut : 4 2 7 1 3 . Bagaimana binary tree nya akan terbentuk ? Binary tree nya akan berbentuk seperti berikut :

       4

       / \

      2   7

     / \

    1   3

Aturan saat “insert” kedalam binary tree ini adalah dengan membandingkan data yang akan dimasukkan dengan kondisi root saat itu. Ok, mari kita telaah ! angka pertama yang akan menjadi “root” adalah 4, maka angka tersebut akan menjadi paling atas. Lalu berikut nya 2, nah disini kita akan membandingkan 2 dengan 4, 2 lebih kecil dibanding 4, maka dia akan diletakkan dikir. Lalu 7, karena 7 lebih besar dari 4, maka 7 diletakkan disebelah kanan. Lalu 1, 1 lebih kecil dibandingkan 4 maka akan masuk ke sebelah kiri, namun karena sebelah kiri sudah memiliki “root” yaitu 2, maka 1 akan dibandingkan kembali dengan 2, karena 1 lebih kecil dibandingkan dengan 2, maka 1 diletakkan disebelah kiri dari 2. Begitu juga berlaku dengan 3.

Dari, penjelasan diatas, dapat disimpukan bahwa binary tree saat “insert” data mengurutkan datanya terlebih dahulu. Lalu apa hubungannya dengan pertanyaan “Apa kegunaan binary tree dalam pemrograman ? ”. Kita ambil kasus simple saja, kita diminta untuk menangani deretan angka yang tidak berurutan, lalu diminta untuk menentukan manakah angka yang terbesar, dengan mudah kita akan langsung mengambil data yang paling kanan sampai tidak memiliki cabang lagi. Kenapa bisa seperti itu ? karena otomatis angka yang memiliki posisi paling kanan dan sudah tidak memiliki cabang dialah angka yang paling besar.