Deletion in a Binary Tree

Given a binary tree, delete a node from it by making sure that tree shrinks from the bottom (i.e. the deleted node is replaced by bottom most and rightmost node). This different from BST deletion. Here we do not have any order among elements, so we replace with last element.
Examples :

Delete 10 in below tree
       10
     /    \         
    20     30
Output :    
       30
     /             
    20     


Delete 20 in below tree
       10
     /    \         
    20     30
            \
            40
Output :    
       10
     /   \             
    40    30   

Algorithm 
1. Starting at root, find the deepest and rightmost node in binary tree and node which we want to delete. 
2. Replace the deepest rightmost node’s data with node to be deleted. 
3. Then delete the deepest rightmost node.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to delete element in binary tree
#include <bits/stdc++.h>
using namespace std;
  
/* A binary tree node has key, pointer to left 
child and a pointer to right child */
struct Node {
    int key;
    struct Node *left, *right;
};
  
/* function to create a new node of tree and 
return pointer */
struct Node* newNode(int key)
{
    struct Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return temp;
};
  
/* Inorder traversal of a binary tree*/
void inorder(struct Node* temp)
{
    if (!temp)
        return;
    inorder(temp->left);
    cout << temp->key << " ";
    inorder(temp->right);
}
  
/* function to delete the given deepest node 
(d_node) in binary tree */
void deletDeepest(struct Node* root,
                  struct Node* d_node)
{
    queue<struct Node*> q;
    q.push(root);
  
    // Do level order traversal until last node
    struct Node* temp;
    while (!q.empty()) {
        temp = q.front();
        q.pop();
        if (temp == d_node) {
            temp = NULL;
            delete (d_node);
            return;
        }
        if (temp->right) {
            if (temp->right == d_node) {
                temp->right = NULL;
                delete (d_node);
                return;
            }
            else
                q.push(temp->right);
        }
  
        if (temp->left) {
            if (temp->left == d_node) {
                temp->left = NULL;
                delete (d_node);
                return;
            }
            else
                q.push(temp->left);
        }
    }
}
  
/* function to delete element in binary tree */
Node* deletion(struct Node* root, int key)
{
    if (root == NULL)
        return NULL;
  
    if (root->left == NULL && root->right == NULL) {
        if (root->key == key)
            return NULL;
        else
            return root;
    }
  
    queue<struct Node*> q;
    q.push(root);
  
    struct Node* temp;
    struct Node* key_node = NULL;
  
    // Do level order traversal to find deepest
    // node(temp) and node to be deleted (key_node)
    while (!q.empty()) {
        temp = q.front();
        q.pop();
  
        if (temp->key == key)
            key_node = temp;
  
        if (temp->left)
            q.push(temp->left);
  
        if (temp->right)
            q.push(temp->right);
    }
  
    if (key_node != NULL) {
        int x = temp->key;
        deletDeepest(root, temp);
        key_node->key = x;
    }
    return root;
}
  
// Driver code
int main()
{
    struct Node* root = newNode(10);
    root->left = newNode(11);
    root->left->left = newNode(7);
    root->left->right = newNode(12);
    root->right = newNode(9);
    root->right->left = newNode(15);
    root->right->right = newNode(8);
  
    cout << "Inorder traversal before deletion : ";
    inorder(root);
  
    int key = 11;
    root = deletion(root, key);
  
    cout << endl;
    cout << "Inorder traversal after deletion : ";
    inorder(root);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to delete element
// in binary tree 
import java.util.LinkedList; 
import java.util.Queue; 
  
class GFG{ 
      
// A binary tree node has key, pointer to 
// left child and a pointer to right child 
static class Node 
    int key; 
    Node left, right; 
      
    // Constructor 
    Node(int key)
    
        this.key = key; 
        left = null
        right = null
    
  
static Node root; 
static Node temp = root; 
  
// Inorder traversal of a binary tree
static void inorder(Node temp) 
    if (temp == null
        return
  
    inorder(temp.left); 
    System.out.print(temp.key + " "); 
    inorder(temp.right); 
  
// Function to delete deepest 
// element in binary tree
static void deleteDeepest(Node root,
                          Node delNode)
{
    Queue<Node> q = new LinkedList<Node>(); 
    q.add(root);
      
    Node temp = null;
      
    // Do level order traversal until last node 
    while (!q.isEmpty())
    
        temp = q.peek(); 
        q.remove();
          
        if (temp == delNode)
        
            temp = null
            return
              
        
        if (temp.right!=null)
        
            if (temp.right == delNode)
            
                temp.right = null
                return
        
        else
            q.add(temp.right); 
    
  
    if (temp.left != null
    
        if (temp.left == delNode)
        
            temp.left = null
            return
        
        else
            q.add(temp.left); 
    
}
  
// Function to delete given element 
// in binary tree
static void delete(Node root, int key)
{
    if (root == null
        return
          
    if (root.left == null && 
       root.right == null)
    
        if (root.key == key) 
            return
        else
            return
    }
      
    Queue<Node> q = new LinkedList<Node>(); 
    q.add(root);
    Node temp = null, keyNode = null;
      
    // Do level order traversal until
    // we find key and last node. 
    while (!q.isEmpty())
    
        temp = q.peek(); 
        q.remove(); 
          
        if (temp.key == key) 
            keyNode = temp; 
  
        if (temp.left != null
            q.add(temp.left); 
  
        if (temp.right != null
            q.add(temp.right); 
    
  
    if (keyNode != null)
    
        int x = temp.key; 
        deleteDeepest(root, temp); 
        keyNode.key = x; 
    
}
  
// Driver code 
public static void main(String args[]) 
    root = new Node(10); 
    root.left = new Node(11); 
    root.left.left = new Node(7);
    root.left.right = new Node(12);
    root.right = new Node(9); 
    root.right.left = new Node(15); 
    root.right.right = new Node(8); 
  
    System.out.print("Inorder traversal " +
                     "before deletion:"); 
    inorder(root); 
  
    int key = 11
    delete(root, key); 
  
    System.out.print("\nInorder traversal " +
                     "after deletion:"); 
    inorder(root); 
  
// This code is contributed by Ravi Kant Verma 

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to illustrate deletion in a Binary Tree
   
# class to create a node with data, left child and right child.
class Node:
    def __init__(self,data):
        self.data = data
        self.left = None
        self.right = None
   
# Inorder traversal of a binary tree
def inorder(temp):
    if(not temp):
        return
    inorder(temp.left)
    print(temp.data, end = " ")
    inorder(temp.right)
   
# function to delete the given deepest node (d_node) in binary tree 
def deleteDeepest(root,d_node):
    q = []
    q.append(root)
    while(len(q)):
        temp = q.pop(0)
        if temp is d_node:
            temp = None
            return
        if temp.right:
            if temp.right is d_node:
                temp.right = None
                return
            else:
                q.append(temp.right)
        if temp.left:
            if temp.left is d_node:
                temp.left = None
                return
            else:
                q.append(temp.left)
   
# function to delete element in binary tree 
def deletion(root, key):
    if root == None :
        return None
    if root.left == None and root.right == None:
        if root.key == key : 
            return None
        else :
            return root
    key_node = None
    q = []
    q.append(root)
    while(len(q)):
        temp = q.pop(0)
        if temp.data == key:
            key_node = temp
        if temp.left:
            q.append(temp.left)
        if temp.right:
            q.append(temp.right)
    if key_node : 
        x = temp.data
        deleteDeepest(root,temp)
        key_node.data = x
    return root
   
# Driver code
if __name__=='__main__':
    root = Node(10)
    root.left = Node(11)
    root.left.left = Node(7)
    root.left.right = Node(12)
    root.right = Node(9)
    root.right.left = Node(15)
    root.right.right = Node(8)
    print("The tree before the deletion:")
    inorder(root)
    key = 11
    root = deletion(root, key)
    print()
    print("The tree after the deletion;")
    inorder(root)
       
# This code is contributed by Monika Anandan

chevron_right


Output

Inorder traversal before deletion : 7 11 12 10 15 9 8 
Inorder traversal after deletion : 7 8 12 10 15 9 

Note: We can also replace node’s data that is to be deleted with any node whose left and right child points to NULL but we only use deepest node in order to maintain the Balance of a binary tree.

This article is contributed by Yash Singla. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :


59


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.