BST added

Author: me-shaon

Data Structure/BST/README.md

@@ -0,0 +1,66 @@
+# Binary Search Tree (BST)
+
+A **Binary Search Tree (BST)** is a tree in which all the nodes follow the below-mentioned properties −
+
+- The left subtree of a node contains only nodes with keys less than the node’s key.
+- The right subtree of a node contains only nodes with keys greater than the node’s key.
+- The left and right subtree each must also be a binary search tree.
+
+BST is a collection of nodes arranged in a way where they maintain BST properties. Each node has a key and an associated value. While searching, the desired key is compared to the keys in BST and if found, the associated value is retrieved.
+
+![BST](binary_search_tree.jpg)
+
+**Basic Operations:**
+
+Following are the basic operations of a tree −
+
+- **Search** − Searches an element in a tree.
+- **Insert** − Inserts an element in a tree.
+- **Pre-order Traversal** − Traverses a tree in a pre-order manner.
+- **In-order Traversal** − Traverses a tree in an in-order manner.
+- **Post-order Traversal** − Traverses a tree in a post-order manner.
+
+##### Search Operation
+
+To search a given key in Binary Search Tree, we first compare it with root, if the key is present at root, we return root. If key is greater than root’s key, we recur for right subtree of root node. Otherwise we recur for left subtree.
+
+![BST Search](bst_search.png)
+
+##### Insertion
+
+Whenever an element is to be inserted, first locate its proper location. Start searching from the root node, then if the data is less than the key value, search for the empty location in the left subtree and insert the data. Otherwise, search for the empty location in the right subtree and insert the data.
+
+![BST Insert](bst_insert.png)
+
+##### Deletion
+
+When we delete a node, there possibilities arise.
+- **Node to be deleted is leaf:** Simply remove from the tree.
+
+![BST Remove-1](bst-remove-case-1.png)
+
+- **Node to be deleted has only one child:** Copy the child to the node and delete the child.
+
+![BST Remove-2-1](bst-remove-case-2-1.png)
+![BST Remove-2-2](bst-remove-case-2-2.png)
+![BST Remove-2-3](bst-remove-case-2-3.png)
+
+- **Node to be deleted has two children:** Find inorder successor of the node. Copy contents of the inorder successor to the node and delete the inorder successor.
+
+![BST Remove-3-3](bst-remove-case-3-3.png)
+![BST Remove-3-4](bst-remove-case-3-4.png)
+![BST Remove-3-5](bst-remove-case-3-5.png)
+![BST Remove-3-6](bst-remove-case-3-6.png)
+
+#### Complexity Analysis
+- Insertion - O(log n)
+- Deletion - O(log n)
+- Access - O(log n)
+- Search - O(log n)
+
+### More on this topic
+- https://www.tutorialspoint.com/data_structures_algorithms/binary_search_tree.htm
+- http://www.algolist.net/Data_structures/Binary_search_tree
+- http://quiz.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion/
+- http://quiz.geeksforgeeks.org/binary-search-tree-set-2-delete/
+- https://en.wikibooks.org/wiki/Data_Structures/Trees#Binary_Search_Trees

Data Structure/BST/binary_search_tree.jpg

@@ -0,0 +1,170 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+typedef struct
+{
+    int number;
+    struct node *leftChild;
+    struct node *rightChild;
+
+} node;
+
+node* root = NULL;
+
+void insertNode(int value)
+{
+    node* tempNode;
+    node* currentNode = NULL;
+
+    tempNode = (node *) malloc(sizeof(node));
+    tempNode->number = value;
+    tempNode->leftChild = NULL;
+    tempNode->rightChild = NULL;
+
+
+    if(root == NULL) //For the very first call
+    {
+        root = tempNode;
+    }
+    else
+    {
+        currentNode = root;
+
+        while(1)
+        {
+            if(value <= currentNode->number)
+            {
+                if(currentNode->leftChild == NULL)
+                {
+                    currentNode->leftChild = tempNode;
+                    break;
+                }
+
+                currentNode = currentNode->leftChild;
+            }
+            else
+            {
+                if(currentNode->rightChild == NULL)
+                {
+                    currentNode->rightChild = tempNode;
+                    break;
+                }
+
+                currentNode = currentNode->rightChild;
+            }
+        }
+    }
+}
+
+void inOrderPrint(node *rootNode) // InOrder Traversal (left-root-right)
+{
+    if(rootNode==NULL)
+        return;
+
+    inOrderPrint(rootNode->leftChild);
+
+    printf("%d ", rootNode->number);
+
+    inOrderPrint(rootNode->rightChild);
+}
+
+node* searchOnTree(int value)
+{
+    node* currentNode = root;
+
+    while(currentNode != NULL)
+    {
+        if(value == currentNode->number)
+        {
+            break;
+        }
+        else if(value <= currentNode->number)
+            currentNode = currentNode->leftChild;
+        else
+            currentNode = currentNode->rightChild;
+    }
+
+    return currentNode;
+}
+
+node * findMinimum(node *currentNode)
+{
+    if(currentNode->leftChild==NULL)
+        return currentNode;
+
+    return findMinimum(currentNode->leftChild);
+}
+
+node * deleteNode(node *currentNode, int value)
+{
+    if(currentNode==NULL) // empty tree
+        return NULL;
+    else if(value < currentNode->number) // value is less than node's number. so go to left subtree
+        currentNode->leftChild = deleteNode(currentNode->leftChild, value);
+    else if(value > currentNode->number) // value is greater than node's number. so go to right subtree
+        currentNode->rightChild = deleteNode(currentNode->rightChild, value);
+    else // node found. Let's delete it!
+    {
+        //node has no child
+        if(currentNode->leftChild == NULL && currentNode->rightChild == NULL)
+        {
+            currentNode = NULL;
+        }
+        else if(currentNode->leftChild == NULL) // node has only right child
+        {
+            currentNode = currentNode->rightChild;
+        }
+        else if(currentNode->rightChild == NULL) // node has only left child
+        {
+            currentNode = currentNode->leftChild;
+        }
+        else // node has two children
+        {
+            node *tempNode = findMinimum(currentNode->rightChild);
+            currentNode->number = tempNode->number;
+            currentNode->rightChild = deleteNode(currentNode->rightChild, tempNode->number);
+        }
+
+    }
+
+    return currentNode;
+}
+
+
+int main()
+{
+    int i, value;
+    //int numbers[] = {45, 54, 40, 49, 38, 70, 30, 39, 41, 45, 44};
+    int numbers[] = {5, 2, 17, 6, 20};
+    int numbers_length = sizeof(numbers)/sizeof(numbers[0]);
+    node* node_to_delete;
+
+    for(i=0;i<numbers_length;i++)
+    {
+        insertNode(numbers[i]);
+    }
+
+    printf("\nIn-Order Tree printing:\n");
+    inOrderPrint(root);
+    puts("");
+
+    value = 70;
+    if(searchOnTree(value) != NULL)
+        printf("\n%d is found on Tree.\n", value);
+    else
+        printf("\n%d is not found on Tree.\n", value);
+
+    value = 100;
+    if(searchOnTree(value) != NULL)
+        printf("\n%d is found on Tree.\n", value);
+    else
+        printf("\n%d is not found on Tree.\n", value);
+
+    deleteNode(root, 5);
+
+    printf("\nIn-Order Tree printing:\n");
+    inOrderPrint(root);
+    puts("");
+
+    return 0;
+}