Summary

1. Circular Single Linked List
Circular single linked list adalah single linked list yang tidak menerima value NULL yang dikarenakan node terakhir akan menunjuk ke head pointer sehingga circular single linked list tidak menerima value NULL.



2. Doubly Linked List
Doubly linked list adalah single linked list yang memiliki 2 arah pointer dimana sebuah node memiliki 2 pointer yaitu next dan prev.



Ada 2 cara untuk menyunting doubly linked list:
a. Insert
Insert digunakan untuk memasukan node baru ke dalam doubly linked list dan mengkoneksikan node tersebut dengan node yang sudah ada.

struct tnode *node = (struct tnode*) malloc (sizeof (struct tnode);
node->value = x;
node->next  = NULL;
node->prev  = tail;
tail->next = node;
tail = node;

b. Delete
Delete digunakan untuk menghapus node tertentu dari doubly linked list.

Jika menghapus node saja:
free  (head);
head = NULL;
tail = NULL;

Jika menghapus head:
head = head.next;
free (head.prev);
head.prev = NULL:

Jika menghapus tail:
tail = tail.prev;
free (tail.next);
tail.next = NULL;

3. Circular Doubly Linked List
Circular Doubly Linked List adalah gabungan dari circular single linked list dan doubly linked list. Di dalam circular doubly linked list sebuah node mempunyai 2 arah pointer dan tidak menerima value NULL atau node terakhir menunjuk ke head pointer.




Konsep Stack dan Queue dalam data struktur:

1. Push()
Push berfungsi untuk memasukkan data.

Ada beberapa push dalam data struktur:
A. PushHead()
Push Head berfungsi untuk memasukkan data dari head. Contoh:

Ada terdapat linked list dengan node berikut:
10, 20.
10 adalah head dan 20 ada tail dan curr.

Jika saya ingin melakukan push head dengan value 30, maka linked list diatas akan menjadi:
30, 10 , 20.
30 adalah head dan 20 tetap tail dan curr,

B. Push Tail()
Push Tail befungsi untuk memasukkan data dari tail. Contoh:
Ada terdapat linked list dengan node berikut:
10, 20.
10 adalah head dan 20 ada tail dan curr.

Jika saya ingin melakukan push tail dengan value 30, maka linked list diatas akan menjadi:
10 , 20, 30.
10 tetap menjadi head dan 30 menjadi tail dan curr,


2. Pop()
Pop berfungsi untuk menghapus data.

Ada beberapa pop dalam data struktur:
A. Pop Head
Pop Head berfungsi untuk menghapus head di sebuah linked list.

B. Pop Tail
Pop Tail berfungsi untuk menghapus tail di sebuah linked list.

Binary Search Tree

Binary Search Tree mempunyai 2 aturan yaitu:
1. Jika value node lebih besar dari node, maka node tersebut akan menjadi leaf kanan node tersebut.
2. Jika value node lebih kecil dari node, maka node tersebut akan menjadi leaf kiri node tersebut.

Ini adalah contoh kode create dan insert untuk binary search tree:
#include<stdio.h>
#include<stdlib.h>

struct node{
int key;
struct node *left, *right;
};

// Function untuk membuat node baru
struct node *newNode(int item){
struct node *temp = (struct node *)malloc(sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}

void inorder(struct node *root)
{
if (root != NULL)
{
inorder(root->left);
printf("%d \n", root->key);
inorder(root->right);
}
}

/* Function untuk insert */
struct node* insert(struct node* node, int key){
if (node == NULL) {
return newNode(key);
}

if (key < node->key){
node->left = insert(node->left, key);
}else if (key > node->key){
node->right = insert(node->right, key);
}

return node;
}

int main(){
/* Kita akan membuat binary search tree seperti ini
50
/ \
/         \
30        70
/ \         / \
20 40   60  80 */

struct node *root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
inorder(root);
return 0;
}

Contoh kode delete untuk binary search tree;
 // C program to demonstrate delete operation in binary search tree
#include<stdio.h>
#include<stdlib.h>

struct node
{
int key;
struct node *left, *right;
};

struct node *newNode(int item)
{
struct node *temp = (struct node *)malloc(sizeof(struct node));
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}

void inorder(struct node *root)
{
if (root != NULL)
{
inorder(root->left);
printf("%d ", root->key);
inorder(root->right);
}
}

/* Function untuk insert*/
struct node* insert(struct node* node, int key)
{
/* If the tree is empty, return a new node */
if (node == NULL) return newNode(key);

/* Otherwise, recur down the tree */
if (key < node->key)
node->left = insert(node->left, key);
else
node->right = insert(node->right, key);

/* return the (unchanged) node pointer */
return node;
}

struct node * minValueNode(struct node* node)
{
struct node* current = node;

/* loop down to find the leftmost leaf */
while (current && current->left != NULL)
current = current->left;

return current;
}

/* Function untuk delete */
struct node* deleteNode(struct node* root, int key)
{
// base case
if (root == NULL) {
            return root;
        }

if (key < root->key) {
root->left = deleteNode(root->left, key);
        }else if (key > root->key) {
root->right = deleteNode(root->right, key);
        } else{
if (root->left == NULL)
{
struct node *temp = root->right;
free(root);
return temp;
}
else if (root->right == NULL)
{
struct node *temp = root->left;
free(root);
return temp;
}
struct node* temp = minValueNode(root->right);
root->key = temp->key;
root->right = deleteNode(root->right, temp->key);
}
return root;
}

int main()
{
/* Kita akan membuat binary search tree seperti ini
           50
 / \
      30  70
      / \         / \
   20 40   60 80 */
struct node *root = NULL;
root = insert(root, 50);
root = insert(root, 30);
root = insert(root, 20);
root = insert(root, 40);
root = insert(root, 70);
root = insert(root, 60);
root = insert(root, 80);

printf("Inorder traversal of the given tree \n");
inorder(root);

printf("\nDelete 20\n");
root = deleteNode(root, 20);
printf("Inorder traversal of the modified tree \n");
inorder(root);

printf("\nDelete 30\n");
root = deleteNode(root, 30);
printf("Inorder traversal of the modified tree \n");
inorder(root);

printf("\nDelete 50\n");
root = deleteNode(root, 50);
printf("Inorder traversal of the modified tree \n");
inorder(root);

return 0;
}

Sumber kode: 

https://www.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion
https://www.geeksforgeeks.org/binary-search-tree-set-2-delete/
http://alvinstrukturdata.blogspot.com/2016/01/apa-itu-linked-list.html