About Linked List

Tuesday, June 16, 2020

Rangkuman

Andrew Dharma Saputra
2301853823

Hari: Selasa, 09/06/2020

Kelas: CB01-CL

Lecturer: Ferdinand Ariandy Luwinda ( D4522 ) dan Henry Chong ( D4460 )

AVL Tree

AVL Tree merupakan tipe binary tree yang dapat menyeimbangkan / self-balancing dirinya sendiri dimana perbedaan tinggi / height dari subtrees kiri dan kanan tidak boleh lebih dari satu untuk semua nodes. Kegunaan dari AVL Tree adalah mempercepat dan membuat operasi BST lebih efisien.

Contoh A

Gambar tree Contoh A diatas merupakan AVL Tree karena perbedaan tingginya hanya 1.

Contoh B

Gambar tree Contoh B dibawah bukanlah merupakan AVL Tree karena perbedaan tingginya lebih dari satu.

AVL Tree Insertion [Rotations]

Rotasi / Rotations AVL Tree dapat dibagi menjadi dua jenis yakni,

a. Single Rotation

Single Rotation dapat dibagi menjadi dua jenis yakni,

Single Left Rotation [LL Rotation]

Single Right Rotation [RR Rotation]

b. Double Rotation

Double Rotation dapat dibagi menjadi dua jenis yakni,

Left Right Rotation [LR Rotation]

Right Left Rotation [RL Rotation]

Penjelasan

Single Rotation

Jika treenya menjadi unbalanced, saat sebuah node di insert ke kanan subtree dari subtree kanan maka kita melakukan single left rotation.

LL Rotation

Sebaliknya jika kondisinya di kiri, maka kita melakukan single right rotation.

RR Rotation

Double Rotation

Left Right rotation adalah kombinasi dari left rotation lalu diikuti dengan right rotation, agar lebih dapat dipahami dapat dilihat dari gambar di bawah.

Sebuah node telah diinsert ke subtree kanan dari subtree kiri,
hal ini membuat tree menjadi tidak balance.

Pertama, kita melakukan left rotation di subtree kiri C,
hal ini membuat A menjadi subtree kiri dari B.

Lalu kita melakukan right rotation kepada treenya,
hal ini membuat B menjadi root baru dari tree dan C menjadi subtree kanan dari B.

Balanced Avl Tree

Untuk Right Left Rotation dilakukan jika kondisinya kebalikannya.

Deletion

Deletion pada AVL Tree sama dengan Deletion pada BST, tetapi Deletion pada AVL Tree dapat menyebabkan ketidakseimbangan / unbalance pada tree. Untuk membuat AVL Tree tetap AVL Tree setelah deletion maka diperlukannya penyeimbangan ulang / re-balancing pada tree.

Heap

Heap adalah data structure yang spesial dimana ia tree-based yang treenya adalah complete binary tree.

Array to Heap

Biasanya Heap dibagi menjadi dua yakni,

Max-Heap dan Min-Heap

Min & Max

Pada Max-Heap key pada root harus lebih besar daripada key semua childnya. Begitu juga untuk childrennya yang menjadi parent harus lebih besar daripada childrennya.

Pada Min-Heap key pada root harus lebih kecil daripada key semua childnya. Begitu juga untuk childrennya yang menjadi parent harus lebih kecil daripada childrennya.

Insertion

Saat kita meng-insert data, data akan dimasukan di index terakhir pada array heap tersebut lalu data akan dibandingkan dengan parentnya, jika kondisi Min/Max Heap dilanggar maka data tersebut akan dipindahkan ke tempat parentnya (Up-Heap).

Deletion

Saat kita meng-delete data pada heap, maka root dari heap akan terhapus, lalu array heap terakhir akan langsung menggantikan root yang terdelete. Lalu data tersebut akan di bandingkan dengan childnya, jika kondisi Min/Max Heap dilanggar maka data tersebut akan dipindahkan ke tempat childnya (Down-Heap).

Trie

Trie adalah data structure yang efisien pada bidang re Trieval data. Bentuk trie sendiri berupa tree yang tiap nodenya di isi dengan karakter.

Trie

Root pada Trie dapat dikosongkan ataupun di isi dengan karakter. Lalu kegunaan trie salah satunya adalah pada searching.

Monday, May 18, 2020

Heap and Trie

Heap
Heap adalah data structure yang spesial dimana ia tree-based yang treenya adalah complete binary tree.

Array to Heap

Biasanya Heap dibagi menjadi dua yakni,

Max-Heap dan Min-Heap

Min & Max

Pada Max-Heap key pada root harus lebih besar daripada key semua childnya. Begitu juga untuk childrennya yang menjadi parent harus lebih besar daripada childrennya.

Pada Min-Heap key pada root harus lebih kecil daripada key semua childnya. Begitu juga untuk childrennya yang menjadi parent harus lebih kecil daripada childrennya.

Insertion

Deletion

Trie

Trie adalah data structure yang efisien pada bidang re Trieval data. Bentuk trie sendiri berupa tree yang tiap nodenya di isi dengan karakter.

Trie

Root pada Trie dapat dikosongkan ataupun di isi dengan karakter. Lalu kegunaan trie salah satunya adalah pada searching.

Referensi:

https://www.geeksforgeeks.org/heap-data-structure/

https://www.geeksforgeeks.org/binary-heap/

https://www.geeksforgeeks.org/trie-insert-and-search/

Monday, May 4, 2020

AVL Tree

AVL Tree
AVL Tree merupakan tipe binary tree yang dapat menyeimbangkan / self-balancing dirinya sendiri dimana perbedaan tinggi / height dari subtrees kiri dan kanan tidak boleh lebih dari satu untuk semua nodes. Kegunaan dari AVL Tree adalah mempercepat dan membuat operasi BST lebih efisien.

Contoh A

Gambar tree Contoh A diatas merupakan AVL Tree karena perbedaan tingginya hanya 1.

Contoh B

Gambar tree Contoh B dibawah bukanlah merupakan AVL Tree karena perbedaan tingginya lebih dari satu.

AVL Tree Insertion [Rotations]

Rotasi / Rotations AVL Tree dapat dibagi menjadi dua jenis yakni,

a. Single Rotation

Single Rotation dapat dibagi menjadi dua jenis yakni,

Single Left Rotation [LL Rotation]

Single Right Rotation [RR Rotation]

b. Double Rotation

Double Rotation dapat dibagi menjadi dua jenis yakni,

Left Right Rotation [LR Rotation]

Right Left Rotation [RL Rotation]

Penjelasan

Single Rotation

Jika treenya menjadi unbalanced, saat sebuah node di insert ke kanan subtree dari subtree kanan maka kita melakukan single left rotation.

LL Rotation

Sebaliknya jika kondisinya di kiri, maka kita melakukan single right rotation.

RR Rotation

Double Rotation

Left Right rotation adalah kombinasi dari left rotation lalu diikuti dengan right rotation, agar lebih dapat dipahami dapat dilihat dari gambar di bawah.

Sebuah node telah diinsert ke subtree kanan dari subtree kiri,
hal ini membuat tree menjadi tidak balance.

Pertama, kita melakukan left rotation di subtree kiri C,
hal ini membuat A menjadi subtree kiri dari B.

Lalu kita melakukan right rotation kepada treenya,
hal ini membuat B menjadi root baru dari tree dan C menjadi subtree kanan dari B.

Balanced Avl Tree

Untuk Right Left Rotation dilakukan jika kondisinya kebalikannya.

Deletion

References:

https://www.tutorialspoint.com/data_structures_algorithms/avl_tree_algorithm.htm

https://www.geeksforgeeks.org/avl-tree-set-1-insertion/

https://www.geeksforgeeks.org/avl-tree-set-2-deletion/

https://binusmaya.binus.ac.id/newStudent/#/class/resources.COMP6048/010544/1920/LEC/12104

Sunday, April 5, 2020

Review Linked List

Review Linked List
Linked List
Linked List merupakan koleksi linear dari data, yang disebut sebagai nodes, dimana setiap node akan menunjuk pada node lain melalui sebuah pointer.

Insertion
Insertion pada linked list memiliki arti memasukan atau menambah data ke dalam linked list. Biasanya disebut dengan push.
More Info: https://linkedlistads.blogspot.com/2020/03/insertsion-deletion-at-linked-list.html

Deletion
Deletion pada linked list memiliki arti menghapus data dari linked list. Biasanya disebut dengan pop.
More Info: https://linkedlistads.blogspot.com/2020/03/insertsion-deletion-at-linked-list.html

Circular Singly Linked List
Circular Singly Linked List adalah singly linked list yang pada node terakhirnya mempunyai sebuah pointer yang menunjuk ke node pertama sehingga jika digambarkan akan membentuk sebuah siklus.

Circular Singly Linked List

More Info: https://linkedlistads.blogspot.com/2020/03/about-linked-list.html

Doubly Linked List

Doubly Linked List adalah linked list yang pada setiap nodenya memiliki sebuah pointer tambahan yang menunjuk ke node sebelumnya (previous node).

Doubly Linked List

More Info: https://linkedlistads.blogspot.com/2020/03/about-linked-list.html

Circular Doubly Linked List

Circular Doubly Linked List adalah doubly linked list yang pada node pertama dan terakhirnya mempunyai pointer tambahan. Pointer tambahan pada node pertama akan menunjuk ke node terakhir, sedangkan pointer tambahan pada node terakhir akan menunjuk ke node pertama.

Circular Doubly Linked List

More Info: https://linkedlistads.blogspot.com/2020/03/about-linked-list.html

Stack

Stack adalah tumpukan dimana ia memiliki sistem Last In First Out (LIFO). Contohnya seperti tumpukan buku, dimana jika kita memiliki tumpukan buku maka buku yang teratas akan diambil terlebih dahulu sedangkan yang pertama kali di letakan adalah buku yang paling bawah.

Queue

Queue adalah antrian dimana ia memiliki sistem First In First Out (FIFO). Contohnya seperti antrian tiket kereta, dimana orang yang mengantri duluan akan mendapatkan tiketnya duluan.

Hashing

Hashing adalah teknik untuk mengubah atau mengconvert sebuah string karakters ke suatu key yang lebih singkat nilainya yang merepresentasikan string originalnya.

Hashing digunakan untuk mengambil items dari database karena lebih cepat untuk menemukan item menggunakan key atau kunci yang lebih pendek atau singkat.

Teknik Hashing ini sangat sering digunakan dalam bilang security, selain itu teknik ini juga digunakan oleh Teknologi Block Chain yang sangat populer sekarang ini. Block Chain digambarkan sebagai sebuah block yang menyimpan data, hash, dan hash of previous block. Ketiga tersebut diproteksi dengan menggunakan hash.

More Info: https://linkedlistads.blogspot.com/2020/03/hash-table-binary-tree-at-data-structure.html

Hash Table

Hash Table adalah tabel dalam bentuk array dimana kita menyimpan string original. Index pada tabel adalah key yang di hash.

More Info: https://linkedlistads.blogspot.com/2020/03/hash-table-binary-tree-at-data-structure.html

Binary Tree
Binary Tree adalah pohon yang memiliki paling banyak 2 anak (children).
What is a Binary Tree

Bahasa - bahasa dalam Tree:

                tree
                ----
level 0 -->       j    <-- root
                /   \
level 1 -->    f      k  <-- f & k adalah children dari j
             /   \      \
level 2--> a      h      z    <-- leaves  | a & h adalah children dari f

More Info: https://linkedlistads.blogspot.com/2020/03/hash-table-binary-tree-at-data-structure.html


Binary Search Tree (BST)

Binary search tree adalah sebuah binary tree data structure yang berlandaskan node.

Binary search tree memiliki keuntungan yakni searching dan sortingnya cepat, dan juga deletion dan insertionnya mudah.

Binary search tree memiliki beberapa sifat yakni:

1. Anak pada bagian kiri dari node x lebih kecil daripada x.

2. Anak pada bagian kanan dari node x lebih besar daripada x.

3. Anak dari node x juga termasuk binary search tree.


Binary search tree memiliki 3 operation basic yakni:

- Searching

- Insertion

- Deletion

More Info: https://linkedlistads.blogspot.com/2020/03/binary-search-tree.html




Berikut ini adalah salah satu contoh penggunaan Linked List:

----Dreamer's Market----
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//---L!L---
struct data {
 char nama[20];
 int qty;
 int price;
 struct data*next, *prev;
} *head, *tail, *curr;

void front_push(char nama[], int qty, int price) {
 curr = (struct data*)malloc(sizeof(struct data));
 strcpy(curr->nama, nama);
 curr->qty = qty;
 curr->price = price;
 if (head == NULL) {
  head = tail = curr;
 } else {
  curr->next = head;
  head->prev = curr;
  head = curr;
 }
 tail->next = NULL;
 head->prev = NULL;
}

void back_push(char nama[], int qty, int price) {
 curr = (struct data*)malloc(sizeof(struct data));
 strcpy(curr->nama, nama);
 curr->qty = qty;
 curr->price = price;
 if (head == NULL) {
  head = tail = curr;
 } else {
  tail->next = curr;
  curr->prev = tail;
  tail = curr;
 }
 tail->next = NULL;
 head->prev = NULL;
}
bool push(char nama[], int qty, int price) {
 curr = head;
 while (curr != NULL) {
  if (strcmp(curr->nama, nama) == 0) return false;
  curr = curr->next;
 }
 curr = (struct data*)malloc(sizeof(struct data));
 strcpy(curr->nama, nama);
 curr->qty = qty;
 curr->price = price;
 if (head == NULL) {
  head = tail = curr;
 } else if (strcmp(curr->nama, head->nama) < 0) {
  front_push(nama, qty, price);
 } else if (strcmp(curr->nama, tail->nama) > 0) {
  back_push(nama, qty, price);
 } else {
  struct data *temp;
  temp = head;
  while (strcmp(temp->next->nama, curr->nama) < 0 ){
   if (temp->next == NULL) break;
   temp = temp->next;
  }
  curr->next = temp->next;
  temp->next->prev = curr;
  temp->next = curr;
  curr->prev = temp;
 }
 return true;
}

void front_pop() {
 curr = head;
 head = head->next;
 free(curr);
 head->prev = NULL;
}

void back_pop() {
 curr = tail;
 tail = tail->prev;
 free(curr);
 tail->next = NULL;
}

void pop(int at, int max) {
 if (at == 1) front_pop();
 else if (at == max) back_pop();
 else {
  struct data *temp = head;
  for (int i = 0; i < at-2; i++) {
   temp = temp->next;
  }
  curr = temp->next;
  temp->next = curr->next;
  curr->next->prev = temp;
  free(curr);
 }
}
//---!!!---
void add_item() {
 getchar();
 while (true) {
  system("cls");
  char item[20];
  int qty;
  printf("Input your item name: ");
  scanf("%[^\n]", item);
  getchar();
  printf("Input your item quantity: ");
  scanf("%d", &qty);
  if (qty < 1) {
   printf("Quantity must larger than 0!", qty);
   getchar();
   continue;
  }
  int price = rand() % 100001;
  bool cond = push(item, qty, price);
  if (cond) {
   return;
  } else {
   printf("Item already exist!");
   getchar();
  }
 }
}

void edit_item() {
 while (true) {
  system("cls");
  curr = head;
  int i = 0;
  int in;
  printf("|---------------------------------------|\n");
  printf("| Num. |      Item Name      | Quantity |\n");
  while (curr != NULL) {
   i++;
   printf("| %-4d | %-19s | %-8d |\n", i, curr->nama, curr->qty);
   curr = curr->next;
  }
  printf("|---------------------------------------|\n");
  printf("Enter Item Number to edit >> ");
  scanf("%d", &in);
  if (in <= i && in > 0) {
   curr = head;
   for (int j = 0; j < in-1; j++) {
    curr = curr->next;
   }
   getchar();
   while (true) {
    char nama[20];
    int qty;
    int price = curr->price;
    system("cls");
    printf("Old Name: %s\n", curr->nama);
    printf("Input New Name: ");
    scanf("%[^\n]", nama);
    struct data *temp = head;
    bool cond = true;
    getchar();
    while (temp != NULL) {
     if (strcmp(temp->nama, nama) == 0) {
      printf("Name Already Exist!");
      cond = false;
      getchar();
      break;
     }
     temp = temp->next;
    }
    if (cond == false) continue;
    printf("Old Quantity: %d\n", curr->qty);
    printf("Input New Quantity: ");
    scanf("%d", &qty);
    if (qty < 1) {
     printf("Quantity must larger than 0!", qty);
     getchar();
     continue;
    }
    printf("---Saved!---");
    strcpy(curr->nama, nama);
    curr->qty = qty;
    getchar();
    return;
   }
  }
 }
}

void remove_item() {
 while (true) {
  system("cls");
  curr = head;
  int i = 0;
  int in;
  printf("|---------------------------------------|\n");
  printf("| Num. |      Item Name      | Quantity |\n");
  while (curr != NULL) {
   i++;
   printf("| %-4d | %-19s | %-8d |\n", i, curr->nama, curr->qty);
   curr = curr->next;
  }
  printf("|---------------------------------------|\n");
  printf("Enter Item Number to Remove >> ");
  scanf("%d", &in);
  if (in <= i && in > 0) {
   pop(in, i);
   printf("---Remove Success!---");
   return;
  }
 }
}

void checkout() {
 curr = head;
 int i = 0;
 int total = 0;
 printf("|-----------------------------------------------------------------|\n");
 printf("| Num. |      Item Name      | Quantity |  Price  |   Sub Price   |\n");
 while (curr != NULL) {
  i++;
  printf("| %-4d | %-19s | %-8d | %-7d | %-13d |\n", i, curr->nama, curr->qty, curr->price, curr->price*curr->qty);
  total += curr->price*curr->qty;
  curr = curr->next;
 }
 printf("|-----------------------------------------------------------------|\n");
 printf("| Total Price : Rp.%-46d |\n", total);
 printf("| Kindness is Free! :)                                            |\n");
 printf("|-----------------------------------------------------------------|\n");
 getchar();
 getchar();
 system("cls");
 
}

void menu() {
 int in;
 do {
 system("cls");
  printf("---Dreamer's Market---\n");
  printf("1. Add Item\n");
  printf("2. Edit Item\n");
  printf("3. Remove Item\n");
  printf("4. Checkout\n");
  printf("0. Exit\n");
  printf(">> ");
  scanf("%d", &in);
  if (in == 1) add_item();
  else if (in == 2) edit_item();
  else if (in == 3) remove_item();
  else if (in == 4) checkout();
 } while (in != 0);
}

int main() {
 menu();
 return 0;
}

Saturday, March 21, 2020

Binary Search Tree

Binary Search Tree
Binary Search Tree (BST)
Binary search tree adalah sebuah binary tree data structure yang berlandaskan node.
Binary search tree memiliki keuntungan yakni searching dan sortingnya cepat, dan juga deletion dan insertionnya mudah.
Binary search tree memiliki beberapa sifat yakni:
1. Anak pada bagian kiri dari node x lebih kecil daripada x.
2. Anak pada bagian kanan dari node x lebih besar daripada x.
3. Anak dari node x juga termasuk binary search tree.

Pada gambar diatas kita dapat lihat bahwa 8 adalah root (akar),
angka 8 tersebut memiliki anak 3 dan 10,
karena 3 < 8 maka dia diletakan di sebelah kiri,
karena 10 > 8 maka dia diletakan di sebelah kanan,
siklus terus berlanjut sampai anak terakhir,
anak terakhir tersebut (1, 4, 7, 13) disebut daun.

Binary search tree memiliki 3 operation basic yakni:
- Searching
- Insertion
- Deletion

BST Search
Misalkan ingin mencari angka 4 dari binary search tree di bawah.

binary search tree downward recursion step involves searching in left subtree or right subtree depending on whether the value is less than or greater than the root

Misalkan x adalah posisi kita,
pencarian dimulai dari root yakni 8,
karena 8 != 4 dan 8 > 4 maka,
x akan pindah ke kiri (3),
karena 3 != 4 dan 3 < 4 maka,
x akan pindah ke kanan (6),
karena 6 != 4 dan 6 > 4 maka,
x akan pindah ke kiri (4),
karena 4 == 4 maka searching selesai.

BST Insertion
Misalkan kita ingin memasukan angka 4 ke dalam binary search tree di bawah.
steps that show how the algorithm of insertion to maintain a tree as binary search tree works

steps that show how the algorithm of insertion to maintain a tree as binary search tree works

Misalkan x adalah posisi kita,
pencarian dimulai dari root yakni 8,
karena 8 > 4 maka,
x pindah ke kiri (3),
karena 3 < 4 maka,
x pindah ke kanan (6),
karena 6 > 4 maka,
x pindah ke kiri,
karena x == null maka,
4 di masukan ke x.

BST Deletion
Deletion pada BST dapat dibagi menjadi 3 kasus.

Kasus 1:
Misalkan kita ingin menghapus angka -4 dari dalam binary search tree di bawah kiri.

Karena -4 tidak memiliki anak maka ia dapat dihapus (seperti gambar di atas kanan).

Kasus 2:
Misalkan kita ingin menghapus angka 18 dari dalam binary search tree di bawah ini.
BST remove example, remove 18 from the tree, pic. 1

BST remove example, remove 18 from the tree, pic. 1

Karena 18 memiliki hanya satu anak maka,
BST remove example, remove 18 from the tree, pic. 2

angka 18 akan dihapus dan parent dari 18 akan disambungkan ke anak dari 18.
BST remove example, remove 18 from the tree, pic. 3

Kasus 3:
Misalkan kita ingin menghapus angka 12 dari dalam binary search tree di bawah ini.
two children case, pic. 1

Misalkan x berada pada angka 12.
Karena 9 tidak ada anak maka akan di cek ke kanan,
karena 19 < 21 dan 19 > 9 maka 19 akan dipilih sebagai pengganti 12,
kita tidak dapat pakai 25 karena 25 > 21.
two children case, pic. 2

Referensi:
https://www.programiz.com/dsa/binary-search-tree
https://www.geeksforgeeks.org/binary-search-tree-data-structure/
https://www.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion/

http://www.algolist.net/Data_structures/Binary_search_tree/Removal

Wednesday, March 11, 2020

Hash Table & Binary Tree at Data Structure

Hash Table & Binary Tree at Data Structure
Hashing
Hashing adalah teknik untuk mengubah atau mengconvert sebuah string karakters ke suatu key yang lebih singkat nilainya yang merepresentasikan string originalnya.
Hashing digunakan untuk mengambil items dari database karena lebih cepat untuk menemukan item menggunakan key atau kunci yang lebih pendek atau singkat.

Hash Table
Hash Table adalah tabel dalam bentuk array dimana kita menyimpan string original. Index pada tabel adalah key yang di hash.
Hash Function

Contoh:

Kita dapat lihat bahwa ada array index yang sama, oleh karena itu kita perlu melakukan Linear Probing.

Bahasa - bahasa dalam Tree:

                tree
                ----
level 0 -->       j    <-- root
                /   \
level 1 -->    f      k  <-- f & k adalah children dari j
             /   \      \
level 2--> a      h      z    <-- leaves  | a & h adalah children dari f

Contoh Source Code Dalam C:


struct node  

{ 

    int data; 

    struct node *left; 

    struct node *right; 

}; 


  

/* newNode() mengalokasi memory untuk new node

dan mengisi child kanan dan kiri dengan NULL */

struct node* newNode(int data) 

{ 

  // Mengalokasi memory untuk node baru  

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

  

  // Memasukan data ke node 

  node->data = data; 

  

  // Menginisialisasi child kiri dan kanan dengan NULL 

  node->left = NULL; 

  node->right = NULL; 

  return(node); 

} 

  



int main() 

{ 

  /*membuat root atau akar*/

  struct node *root = newNode(81);

   

  /* gambaran tree yang terbentuk  

       81

      /   \ 

     NULL  NULL   

  */




  root->left        = newNode(27); 

  root->right       = newNode(3); 

  /* 27 dan 3 menjadi children dari 81

          81 

         /   \ 

       27       3 

     /    \    /  \ 

    NULL NULL NULL NULL 

  */

    

  root->left->left  = newNode(9); 

  /* 9 menjadi child dari 27

          81 

       /       \ 

     27          3 

    /   \       /  \ 

   9    NULL  NULL  NULL 

  /  \ 

NULL NULL 

*/

  getchar(); 

  return 0; 

}

Source Code Dari: https://www.geeksforgeeks.org/binary-tree-set-1-introduction/
Referensi:
https://www.tutorialspoint.com/data_structures_algorithms/hash_data_structure.htm
https://binusmaya.binus.ac.id/newStudent/#/class/resources.COMP6048/010544/1920/CL/11725
https://visualgo.net/en/hashtable?slide=1
https://www.w3schools.in/data-structures-tutorial/binary-trees/
https://www.geeksforgeeks.org/binary-tree-data-structure/
https://www.w3schools.in/data-structures-tutorial/binary-trees/
https://www.geeksforgeeks.org/binary-tree-set-1-introduction/
http://cslibrary.stanford.edu/110/BinaryTrees.html