Merge pull request #593 from sanu-020/main

Some Tree programs added in C

Author: gantavyamalviya

Trees/BST.C

@@ -0,0 +1,173 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct Node
+{
+    struct Node *lchild;
+    int data;
+    struct Node *rchild;
+} *root = NULL;
+
+void Insert(int key)
+{
+    struct Node *t = root;
+    struct Node *r, *p;
+
+    if (root == NULL)
+    {
+        p = (struct Node *)malloc(sizeof(struct Node));
+        p->data = key;
+        p->lchild = p->rchild = NULL;
+        root = p;
+        return;
+    }
+    while (t != NULL)
+    {
+        r = t;
+        if (key < t->data)
+            t = t->lchild;
+        else if (key > t->data)
+            t = t->rchild;
+        else
+            return;
+    }
+    p = (struct Node *)malloc(sizeof(struct Node));
+    p->data = key;
+    p->lchild = p->rchild = NULL;
+
+    if (key < r->data)
+        r->lchild = p;
+    else
+        r->rchild = p;
+}
+
+void Inorder(struct Node *p)
+{
+    if (p)
+    {
+        Inorder(p->lchild);
+        printf("%d ", p->data);
+        Inorder(p->rchild);
+    }
+}
+
+struct Node *Search(int key)
+{
+    struct Node *t = root;
+
+    while (t != NULL)
+    {
+        if (key == t->data)
+            return t;
+        else if (key < t->data)
+            t = t->lchild;
+        else
+            t = t->rchild;
+    }
+    return NULL;
+}
+
+struct Node *RInsert(struct Node *p, int key)
+{
+    struct Node *t = NULL;
+    if (p == NULL)
+    {
+        t = (struct Node *)malloc(sizeof(struct Node));
+        t->data = key;
+        t->lchild = t->rchild = NULL;
+        return t;
+    }
+    if (key < p->data)
+        p->lchild = RInsert(p->lchild, key);
+    else if (key > p->data)
+        p->rchild = RInsert(p->rchild, key);
+    return p;
+}
+
+int Height(struct Node *p)
+{
+    int x, y;
+    if (p == NULL)
+        return 0;
+    x = Height(p->lchild);
+    y = Height(p->rchild);
+    return x > y ? x + 1 : y + 1;
+}
+
+struct Node *InPre(struct Node *p)
+{
+    while (p && p->rchild != NULL)
+        p = p->rchild;
+    return p;
+}
+
+struct Node *InSucc(struct Node *p)
+{
+    while (p && p->lchild != NULL)
+        p = p->lchild;
+    return p;
+}
+
+struct Node *Delete(struct Node *p, int key)
+{
+    struct Node *q = NULL;
+    if (p == NULL)
+        return NULL;
+    if (p->lchild == NULL && p->rchild == NULL)
+    {
+        if (p == root)
+            root = NULL;
+        free(p);
+        return NULL;
+    }
+
+    if (key < p->data)
+        p->lchild = Delete(p->lchild, key);
+    else if (key > p->data)
+        p->rchild = Delete(p->rchild, key);
+    else
+    {
+        if (Height(p->lchild) > Height(p->rchild))
+        {
+            q = InPre(p->lchild);
+            p->data = q->data;
+            p->lchild = Delete(p->lchild, q->data);
+        }
+        else
+        {
+            q = InSucc(p->rchild);
+            p->data = q->data;
+            p->rchild = Delete(p->rchild, q->data);
+        }
+    }
+    return p;
+}
+
+int main()
+{
+    struct Node *temp;
+
+    root = RInsert(root, 10);
+    RInsert(root, 10);
+    RInsert(root, 40);
+    RInsert(root, 20);
+    RInsert(root, 30);
+    RInsert(root, 25);
+    RInsert(root, 35);
+    RInsert(root, 55);
+
+    Delete(root, 30);
+
+    Inorder(root);
+    printf("\n");
+
+    temp = Search(20);
+    if (temp != NULL)
+        printf("Element %d is found\n", temp->data);
+    else
+    {
+        printf("Element is not found\n");
+    }
+
+    return 0;
+}

Trees/Binary_tree_Array.c

@@ -0,0 +1,93 @@
+#include <stdio.h>
+
+
+int complete_node = 15;
+
+char tree[] = {'\0', 'D', 'A', 'F', 'E', 'B', 'R', 'T', 'G', 'Q', '\0', '\0', 'V', '\0', 'J', 'L'};
+
+// funtion to get parent
+int get_parent(int index)
+{
+    if(tree[index]!='\0' && index>1 && index<=complete_node) //root has no parent
+        return index/2;
+    return -1;
+}
+
+int get_right_child(int index)
+{
+    // node is not null
+    // and the result must lie within the number of nodes for a complete binary tree
+    if(tree[index]!='\0' && ((2*index)+1)<=complete_node)
+        return (2*index)+1;
+    // right child doesn't exist
+    return -1;
+}
+
+int get_left_child(int index)
+{
+    // node is not null
+    // and the result must lie within the number of nodes for a complete binary tree
+    if(tree[index]!='\0' && (2*index)<=complete_node)
+        return 2*index;
+    // left child doesn't exist
+    return -1;
+}
+
+void preorder(int index)
+{
+    // checking for valid index and null node
+    if(index>0 && tree[index]!='\0')
+    {
+        printf(" %c ",tree[index]); // visiting root
+        preorder(get_left_child(index)); //visiting left subtree
+        preorder(get_right_child(index)); //visiting right subtree
+    }
+}
+
+void postorder(int index)
+{
+    // checking for valid index and null node
+    if(index>0 && tree[index]!='\0')
+    {
+        postorder(get_left_child(index)); //visiting left subtree
+        postorder(get_right_child(index)); //visiting right subtree
+        printf(" %c ",tree[index]); //visiting root
+    }
+}
+
+void inorder(int index)
+{
+    // checking for valid index and null node
+    if(index>0 && tree[index]!='\0')
+    {
+        inorder(get_left_child(index)); //visiting left subtree
+        printf(" %c ",tree[index]); //visiting root
+        inorder(get_right_child(index)); // visiting right subtree
+    }
+}
+
+int is_leaf(int index)
+{
+    // to check of the indices of the left and right children are valid or not
+    if(!get_left_child(index) && !get_right_child(index))  
+        return 1;
+    // to check if both the children of the node are null or not
+    if(tree[get_left_child(index)]=='\0' && tree[get_right_child(index)]=='\0')
+        return 1;
+    return 0; // node is not a leaf
+}
+
+int get_max(int a, int b)
+{
+    return (a>b) ? a : b;
+}
+
+int get_height(int index)
+{
+    // if the node is a leaf the the height will be 0
+    // the height will be 0 also for the invalid cases
+    if(tree[index]=='\0' || index<=0 || is_leaf(index))
+        return 0;
+    // height of node i is 1+ maximum among the height of left subtree and the height of right subtree
+    return(get_max(get_height(get_left_child(index)), get_height(get_right_child(index)))+1);
+}