deletion in bst

Comment

-2

// C++ program to demonstrate 
// delete operation in binary
// search tree
#include <bits/stdc++.h>
using namespace std;

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);
        cout << 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 && 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 has no child
        if (root->left==NULL and root->right==NULL)
            return NULL;
      
        // node with only one child or no child
        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;
        }

        // 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 Code
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);

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

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

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

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

    return 0;
}

// This code is contributed by shivanisinghss2110

Popularity 10/10 Helpfulness 1/10 Language cpp

Source: www.geeksforgeeks.org

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Jan 14 2022

Easy Elk

0 Answers Avg Quality 2/10

Deletion in binary search tree (bst)

Comment

1

/*
 * Program  : Binary Search Tree Deletion
 * Language : C
 */

#include<stdio.h>
#include<stdlib.h>

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

struct node *getNewNode(int val)
{
    struct node *newNode = malloc(sizeof(struct node));
    newNode->key   = val;
    newNode->left  = NULL;
    newNode->right = NULL;

    return newNode;
}

struct node *insert(struct node *root, int val)
{
    if(root == NULL)
        return getNewNode(val);
    if(root->key < val)
        root->right = insert(root->right,val);
    else if(root->key > val)
        root->left = insert(root->left,val);

    return root;
}

int getRightMin(struct node *root)
{
    struct node *temp = root;

    //min value should be present in the left most node.
    while(temp->left != NULL){ temp = temp->left;}

    return temp->key;
}

struct node *removeNode(struct node *root, int val)
{
    /*
     * If the node becomes NULL, it will return NULL
     * Two possible ways which can trigger this case
     * 1. If we send the empty tree. i.e root == NULL
     * 2. If the given node is not present in the tree.
     */
    if(root == NULL)
        return NULL;
    /*
     * If root->key < val. val must be present in the right subtree
     * So, call the above remove function with root->right
     */
    if(root->key < val)
        root->right = removeNode(root->right,val);
    /*
     * if root->key > val. val must be present in the left subtree
     * So, call the above function with root->left
     */
    else if(root->key > val)
        root->left = removeNode(root->left,val);
    /*
     * This part will be executed only if the root->key == val
     * The actual removal starts from here
     */
    else
    {
        /*
         * Case 1: Leaf node. Both left and right reference is NULL
         * replace the node with NULL by returning NULL to the calling pointer.
         * free the node
         */
        if(root->left == NULL && root->right == NULL)
        {
            free(root);
            return NULL;
        }
        /*
         * Case 2: Node has right child.
         * replace the root node with root->right and free the right node
         */
        else if(root->left == NULL)
        {
            struct node *temp = root->right;
            free(root);
            return temp;
        }
        /*
         * Case 3: Node has left child.
         * replace the node with root->left and free the left node
         */
        else if(root->right == NULL)
        {
            struct node *temp = root->left;
            free(root);
            return temp;
        }
        /*
         * Case 4: Node has both left and right children.
         * Find the min value in the right subtree
         * replace node value with min.
         * And again call the remove function to delete the node which has the min value.
         * Since we find the min value from the right subtree call the remove function with root->right.
         */
        else
        {
            int rightMin = getRightMin(root->right);
            root->key = rightMin;
            root->right = removeNode(root->right,rightMin);
        }

    }

    //return the actual root's address
    return root;
}

/*
 * it will print the tree in ascending order
 */
void inorder(struct node *root)
{
    if(root == NULL)
        return;
    inorder(root->left);
    printf("%d ",root->key);
    inorder(root->right);
}

int main()
{
    /*
         100
         / \
        50  200
            /  \
           150  300
     */
    struct node *root = NULL;
    root = insert(root,100);
    root = insert(root,50);
    root = insert(root,200);
    root = insert(root,150);
    root = insert(root,300);

    printf("Initial tree :\t");
    inorder(root);
    printf("\n");

    /* remove leaf node 300
         100
         / \
        50  200
            /
           150
     */
    root = removeNode(root,300);
    printf("After deletion of 300, the new tree :\t");
    inorder(root);
    printf("\n");

    /* remove root node 100
         150
         / \
        50  200
     */
    root = removeNode(root,100);
    printf("After deletion of 100, the new tree :\t");
    inorder(root);
    printf("\n");

    return 0;
}

Popularity 9/10 Helpfulness 2/10 Language whatever

Source: www.log2base2.com

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Dec 02 2022

beingarifkhan

0 Answers Avg Quality 2/10

remove in bst

Comment

0

struct Node{
    Node *left, *right;
    int val;
    Node(int data){
        val=data;
        left=right=NULL;
    }
};

Node* inordersuccessor(Node* root){
    Node* curr=root;
    while(curr!=NULL && curr->left!=NULL){
        curr=curr->left;
    }
    return curr;
}

Node* remove(Node* root, int x){
    if(root==NULL) return root;
    else if(x<root->val){
        root->left=remove(root->left,x);
    }
    else if(x>root->val){
        root->right=remove(root->right,x);
    }
    else{
        if(root->left==NULL){
            Node* temp=root->right;
            delete(root);
            return temp;
        }
        else if(root->right==NULL){
            Node* temp=root->left;
            delete(root);
            return temp;
        }
        else{
            Node* ins=inordersuccessor(root->right);
            root->val=ins->val;
            root->right=remove(root->right,ins->val);
        }
        
    }
    return root;
}

Popularity 9/10 Helpfulness 1/10 Language cpp

Source: Grepper

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Oct 29 2022

Homely Hawk

0 Answers Avg Quality 2/10

Deletion in binary search tree (bst)

Comment

0

(step 2)           (step 3)
  100                                           100                 100
  / \                                           / \                 / \
50  200         delete(200)                    50  300             50  300
    / \         (right subtree min = 300)          / \                 /
  150  300      (step 1)                          150 300             150

Popularity 9/10 Helpfulness 1/10 Language whatever

Source: www.log2base2.com

Tags: binary-search-tree binary-search-tre

Share

Link to this answer
Share Copy Link

Contributed on Dec 02 2022

beingarifkhan

0 Answers Avg Quality 2/10

deletion in bst

Contents

More Related Answers

deletion in bst

Closely Related Answers

Deletion in binary search tree (bst)

remove in bst

Deletion in binary search tree (bst)

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.