binary search tree delete | Exam-Lib
  1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

binary search tree delete

abdelouafiDec 1, 2017

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      617
      Likes Received:
      12
      Trophy Points:
      18
      Joined
      Sep 13, 2016
      binary search tree delete:

      We have discussed BST search and insert operations. In this post, delete operation is discussed. When we delete a node, there possibilities arise.


      upload_2017-12-1_21-38-40.png
      upload_2017-12-1_21-39-24.png

      Code:
      // C program to demonstrate delete operation in binary search tree
      #include<stdio.h>
      #include<stdlib.h>
      struct node
      {
          int key;
          struct node *left, *right;
      };
      // A utility function to create a new BST node
      struct node *newNode(int item)
      {
          struct node *temp =  (struct node *)malloc(sizeof(struct node));
          temp->key = item;
          temp->left = temp->right = NULL;
          return temp;
      }
      // A utility function to do inorder traversal of BST
      void inorder(struct node *root)
      {
          if (root != NULL)
          {
              inorder(root->left);
              printf("%d ", root->key);
              inorder(root->right);
          }
      }
      /* A utility function to insert a new node with given key in BST */
      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;
      }
      /* Given a non-empty binary search tree, return the node with minimum
         key value found in that tree. Note that the entire tree does not
         need to be searched. */
      struct node * minValueNode(struct node* node)
      {
          struct node* current = node;
          /* loop down to find the leftmost leaf */
          while (current->left != NULL)
              current = current->left;
          return current;
      }
      /* Given a binary search tree and a key, this function deletes the key
         and returns the new root */
      struct node* deleteNode(struct node* root, int key)
      {
          // base case
          if (root == NULL) return root;
          // If the key to be deleted is smaller than the root's key,
          // then it lies in left subtree
          if (key < root->key)
              root->left = deleteNode(root->left, key);
          // If the key to be deleted is greater than the root's key,
          // then it lies in right subtree
          else if (key > root->key)
              root->right = deleteNode(root->right, key);
          // if key is same as root's key, then This is the node
          // to be deleted
          else
          {
              // node with only one child or no child
              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;
              }
              // node with two children: Get the inorder successor (smallest
              // in the right subtree)
              struct node* temp = minValueNode(root->right);
              // Copy the inorder successor's content to this node
              root->key = temp->key;
              // Delete the inorder successor
              root->right = deleteNode(root->right, temp->key);
          }
          return root;
      }
      // Driver Program to test above functions
      int main()
      {
          /* Let us create following BST
                    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;
      }

      upload_2017-12-1_21-40-23.png
      upload_2017-12-1_21-40-45.png
       
      Loading...

Share This Page

Share