Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Deletion of a given node K in a Binary Tree using Level Order Traversal

  • Difficulty Level : Medium
  • Last Updated : 11 Jun, 2021

Given a binary tree and a node K, the task is to delete the node K from it by making sure that tree shrinks from the bottom (i.e. the deleted node is replaced by bottom-most and rightmost node) using Level Order Traversal.

Examples: 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: K = 8, Tree = 
 



Output: 
 

Explanation: 
Please Refer below for explanation.

Input: K = 1, Tree = 
 

Output: 
 

Approach: 

  • Start searching from the root, the address of node which is to be deleted by traversing in level order-wise.
  • Continue Traversing Tree to find the deepest and rightmost node in level order wise to find the deepest and the rightmost node.
  • If the node to delete is different from rightmost deepest node, then replace the node to be deleted with rightmost deepest node and delete the later node
  • If the node to delete is same as rightmost deepest node, then simply delete the node.

For example: Consider the Example 1 from above 
 

Below is the implementation of the above approach.

C++




// C++ implementation to delete a node
// in Binary Tree using Level Order Traversal
 
#include <bits/stdc++.h>
using namespace std;
 
// Structure of Binary Tree
struct node {
    int data;
    node* left;
    node* right;
};
 
// Function to create new node
// of a Binary Tree.
node* newnode(int d)
{
    node* temp = new node;
    temp->data = d;
    temp->left = temp->right = NULL;
    return temp;
}
 
// Function for Level Order
// Traversal of Binary Tree
void levelorder(node* curr)
{
 
    // Queue to store the nodes
    // in a level
    queue<node*> q;
    if (curr)
        q.push(curr);
 
    // Loop to Traverse the Binary
    // Tree in Level Order
    while (!q.empty()) {
        curr = q.front();
        q.pop();
        cout << curr->data << " ";
        if (curr->left)
            q.push(curr->left);
        if (curr->right)
            q.push(curr->right);
    }
}
 
// Function to Delete the deepest
// right-most node of the Binary Tree
void deletedeepest(node* root,
                node* temp)
{
    queue<node*> q;
    q.push(root);
 
    // Loop to Traverse Binary Tree
    // in level order and delete Node
    while (!q.empty()) {
        node* T = q.front();
        q.pop();
        if (T->right == temp) {
            T->right = NULL;
            delete (temp);
            return;
        }
        else
            q.push(T->right);
        if (T->left == temp) {
            T->left = NULL;
            delete (temp);
            return;
        }
        else
            q.push(T->left);
    }
}
 
// Function to Delete Node
// in Binary Tree
node* deletenode(node* root, int data)
{
    if (root == NULL)
        return NULL;
 
    // Condition if the Root node
    // is a leaf node.
    if (root->left == NULL
        && root->right == NULL) {
        if (root->data == data) {
            return NULL;
        }
        else
            return root;
    }
    queue<node*> q;
    q.push(root);
    node* temp = NULL;
    node* nodetodelete = NULL;
 
    // Loop to Traverse Tree in
    // Level Order and find the
    // Rightmost Deepest Node of the
    // Binary Tree and Node to be Deleted
    while (!q.empty()) {
        temp = q.front();
        q.pop();
        if (temp->data == data) {
            nodetodelete = temp;
        }
        if (temp->left) {
            q.push(temp->left);
        }
        if (temp->right) {
            q.push(temp->right);
        }
    }
 
    // if node to be deleted is not found
    if (nodetodelete != NULL) {
 
        // Condition to check if node to delete
        // is not same as node to replace
        if (temp != nodetodelete) {
            int t = temp->data;
            deletedeepest(root, temp);
            nodetodelete->data = t;
        }
 
        // if node to delete is also
        // rightmost deepest node
        else {
            deletedeepest(root, temp);
        }
    }
    return root;
}
 
// Driver Code
int main()
{
 
    // Construction of Tree
    node* root = newnode(1);
    root->left = newnode(8);
    root->right = newnode(3);
    root->left->left = newnode(4);
    root->left->right = newnode(5);
    root->right->left = newnode(6);
    root->right->right = newnode(7);
 
    cout << "Original Tree: ";
    levelorder(root);
 
    // Deleting node with key 8
    root = deletenode(root, 8);
    cout << endl;
    cout << "Deleting node with key 8: ";
    levelorder(root);
 
    // Deleting node with key 1
    root = deletenode(root, 1);
    cout << endl;
    cout << "Deleting node with key 1: ";
    levelorder(root);
 
    // Deleting node with key 4
    root = deletenode(root, 4);
    cout << endl;
    cout << "Deleting node with key 4: ";
    levelorder(root);
}

Java




// Java implementation to delete a node
// in Binary Tree using Level Order Traversal
import java.util.LinkedList;
import java.util.Queue;
 
// Binary Tree
class TreeNode
{
    int data;
    TreeNode left = null;
    TreeNode right = null;
     
    TreeNode(int data)
    {
        this.data = data;
    }
}
 
class BinaryTreeDeleteKNode{
 
public TreeNode insert(TreeNode root,
                    int value)
{
    if (root == null)
    {
        root = new TreeNode(value);
        return root;
    }
     
    // Do level order traversal and add
    // node to first null
    Queue<TreeNode> q = new LinkedList<TreeNode>();
    q.add(root);
     
    while (!q.isEmpty())
    {
        TreeNode tn = q.remove();
        if (tn.left != null)
        {
            q.add(tn.left);
        }
        else
        {
            tn.left = new TreeNode(value);
            return root;
        }
        if (tn.right != null)
        {
            q.add(tn.right);
        }
        else
        {
            tn.right = new TreeNode(value);
            return root;
        }
    }
    return root;
}
 
// Function for Level Order
// Traversal of Binary Tree
public void levelOrder(TreeNode root)
{
    if (root == null)
    {
        System.out.println("Tree is empty!!");
    }
     
    // Queue to store the nodes
    // in a level
    Queue<TreeNode> q = new LinkedList<TreeNode>();
    q.add(root);
     
    // Loop to Traverse the Binary
    // Tree in Level Order
    while (!q.isEmpty())
    {
        TreeNode tn = q.remove();
        System.out.print(tn.data + " ");
         
        if (tn.left != null)
            q.add(tn.left);
        if (tn.right != null)
            q.add(tn.right);
    }
}
 
// Function to delete node node with value K
public TreeNode deleteIn(TreeNode root, int k)
{
    if (root == null)
        return root;
     
    // Do level order traversal if node found
    // with the value k then select that node
    // keep traversal till we find deepest
    // node with empty value keep track of
    // the parent node of the deepest node
    TreeNode searchedNode = null;
    TreeNode tn = null;
     
    Queue<TreeNode> q = new LinkedList<TreeNode>();
    TreeNode deepestNodeParent = null;
    q.add(root);
     
    while (!q.isEmpty())
    {
        boolean isParent = false;
        tn = q.remove();
         
        if (searchedNode == null && tn.data == k)
        {
            searchedNode = tn;
        }
        if (tn.left != null)
        {
            q.add(tn.left);
            isParent = true;
        }
        if (tn.right != null)
        {
            q.add(tn.right);
            isParent = true;
        }
        if (isParent) deepestNodeParent = tn;
    }
 
    if (searchedNode == null)
    {
        System.out.print("Node with value '" + k +
                        "' not exists.");
        return root;
    }
    searchedNode.data = tn.data;
    if (deepestNodeParent != null &&
        deepestNodeParent.left != null &&
        deepestNodeParent.left.data == tn.data)
    {
    deepestNodeParent.left = null;
    }
    else
    {
        deepestNodeParent.right = null;
    }
    return root;
}
 
// Driver code
public static void main(String[] args)
{
    TreeNode node = null;
    BinaryTreeDeleteKNode binaryTreeDeleteKNode = new BinaryTreeDeleteKNode();
     
    // Construction of Tree
    node = binaryTreeDeleteKNode.insert(node, 1);
    node = binaryTreeDeleteKNode.insert(node, 8);
    node = binaryTreeDeleteKNode.insert(node, 3);
    node = binaryTreeDeleteKNode.insert(node, 4);
    node = binaryTreeDeleteKNode.insert(node, 5);
    node = binaryTreeDeleteKNode.insert(node, 6);
    node = binaryTreeDeleteKNode.insert(node, 7);
     
    System.out.print("Original Tree: ");
    binaryTreeDeleteKNode.levelOrder(node);
     
    // Deleting node with key 8
    node = binaryTreeDeleteKNode.deleteIn(node,8);
    System.out.print("\nDeleting node with key 8: ");
    binaryTreeDeleteKNode.levelOrder(node);
     
    // Deleting node with key 1
    node = binaryTreeDeleteKNode.deleteIn(node,1);
    System.out.print("\nDeleting node with key 1: ");
    binaryTreeDeleteKNode.levelOrder(node);
     
    // Deleting node with key 4
    node = binaryTreeDeleteKNode.deleteIn(node,4);
    System.out.print("\nDeleting node with key 4: ");
    binaryTreeDeleteKNode.levelOrder(node);
}
}
 
// This code is contributed by anshulgtbit91

Python3




# Python3 implementation to delete a node
# in Binary Tree using Level Order Traversal
from collections import deque
 
# Structure of Binary Tree
class Node:
     
    def __init__(self, x):
         
        self.data = x
        self.left = None
        self.right = None
 
# Function for Level Order
# Traversal of Binary Tree
def levelorder(curr):
     
    # Queue to store the nodes
    # in a level
    q = deque()
 
    if (curr):
        q.append(curr)
 
    # Loop to Traverse the Binary
    # Tree in Level Order
    while len(q) > 0:
        curr = q.popleft()
        #q.pop()
        print(curr.data, end = " ")
         
        if (curr.left):
            q.append(curr.left)
        if (curr.right):
            q.append(curr.right)
 
# Function to Delete the deepest
# right-most node of the Binary Tree
def deletedeepest(root, temp):
     
    q = deque()
    q.append(root)
 
    # Loop to Traverse Binary Tree
    # in level order and delete Node
    while (len(q) > 0):
        T = q.popleft()
        #q.pop()
         
        if (T.right == temp):
            T.right = None
            #delete (temp)
            return
        else:
            q.append(T.right)
             
        if (T.left == temp):
            T.left = None
            #delete (temp)
            return
        else:
            q.append(T.left)
 
# Function to Delete Node
# in Binary Tree
def deletenode(root, data):
     
    if (root == None):
        return None
 
    # Condition if the Root node
    # is a leaf node.
    if (root.left == None and
        root.right == None):
        if (root.data == data):
            return None
        else:
            return root
 
    q = deque()
    q.append(root)
    temp = None
    nodetodelete = None
 
    # Loop to Traverse Tree in
    # Level Order and find the
    # Rightmost Deepest Node of the
    # Binary Tree and Node to be Deleted
    while (len(q) > 0):
        temp = q.popleft()
        #q.pop()
         
        if (temp.data == data):
            nodetodelete = temp
        if (temp.left):
            q.append(temp.left)
        if (temp.right):
            q.append(temp.right)
 
    # If node to be deleted is not found
    if (nodetodelete != None):
         
        # Condition to check if node to delete
        # is not same as node to replace
        if (temp != nodetodelete):
            t = temp.data
            deletedeepest(root, temp)
            nodetodelete.data = t
             
        # If node to delete is also
        # rightmost deepest node
        else:
            deletedeepest(root, temp)
             
    return root
 
# Driver Code
if __name__ == '__main__':
     
    # Construction of Tree
    root = Node(1)
    root.left = Node(8)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)
 
    print("Original Tree: ", end = "")
    levelorder(root)
 
    # Deleting node with key 8
    root = deletenode(root, 8)
    print()
    print("Deleting node with key 8: ", end = "")
    levelorder(root)
 
    # Deleting node with key 1
    root = deletenode(root, 1)
    print()
    print("Deleting node with key 1: ", end = "")
    levelorder(root)
 
    # Deleting node with key 4
    root = deletenode(root, 4)
    print()
    print("Deleting node with key 4: ", end = "")
    levelorder(root)
     
# This code is contributed by mohit kumar 29

Javascript




<script>
// Javascript implementation to delete a node
// in Binary Tree using Level Order Traversal
 
// Binary Tree
class TreeNode
{
    constructor(data)
    {
        this.data=data;
        this.left=this.right=null;
    }
}
 
function insert(root,value)
{
    if (root == null)
    {
        root = new TreeNode(value);
        return root;
    }
      
    // Do level order traversal and add
    // node to first null
    let q = [];
    q.push(root);
      
    while (q.length!=0)
    {
        let tn = q.shift();
        if (tn.left != null)
        {
            q.push(tn.left);
        }
        else
        {
            tn.left = new TreeNode(value);
            return root;
        }
        if (tn.right != null)
        {
            q.push(tn.right);
        }
        else
        {
            tn.right = new TreeNode(value);
            return root;
        }
    }
    return root;
}
 
// Function for Level Order
// Traversal of Binary Tree
function levelOrder(root)
{
if (root == null)
    {
        document.write("Tree is empty!!<br>");
    }
      
    // Queue to store the nodes
    // in a level
    let q = [];
    q.push(root);
      
    // Loop to Traverse the Binary
    // Tree in Level Order
    while (q.length!=0)
    {
        let tn = q.shift();
        document.write(tn.data + " ");
          
        if (tn.left != null)
            q.push(tn.left);
        if (tn.right != null)
            q.push(tn.right);
    }
}
 
// Function to delete node node with value K
function deleteIn(root,k)
{
    if (root == null)
        return root;
      
    // Do level order traversal if node found
    // with the value k then select that node
    // keep traversal till we find deepest
    // node with empty value keep track of
    // the parent node of the deepest node
    let searchedNode = null;
    let tn = null;
      
    let q = [];
    let deepestNodeParent = null;
    q.push(root);
      
    while (q.length!=0)
    {
        let isParent = false;
        tn = q.shift();
          
        if (searchedNode == null && tn.data == k)
        {
            searchedNode = tn;
        }
        if (tn.left != null)
        {
            q.push(tn.left);
            isParent = true;
        }
        if (tn.right != null)
        {
            q.push(tn.right);
            isParent = true;
        }
        if (isParent) deepestNodeParent = tn;
    }
  
    if (searchedNode == null)
    {
        document.write("Node with value '" + k +
                        "' not exists.");
        return root;
    }
    searchedNode.data = tn.data;
    if (deepestNodeParent != null &&
        deepestNodeParent.left != null &&
        deepestNodeParent.left.data == tn.data)
    {
    deepestNodeParent.left = null;
    }
    else
    {
        deepestNodeParent.right = null;
    }
    return root;
}
 
// Driver code
let node = null;
// Construction of Tree
node = insert(node, 1);
node = insert(node, 8);
node = insert(node, 3);
node = insert(node, 4);
node = insert(node, 5);
node = insert(node, 6);
node = insert(node, 7);
 
document.write("Original Tree: ");
levelOrder(node);
 
// Deleting node with key 8
node = deleteIn(node,8);
document.write("<br>Deleting node with key 8: ");
levelOrder(node);
 
// Deleting node with key 1
node = deleteIn(node,1);
document.write("<br>Deleting node with key 1: ");
levelOrder(node);
 
// Deleting node with key 4
node = deleteIn(node,4);
document.write("<br>Deleting node with key 4: ");
levelOrder(node);
         
 
 
// This code is contributed by unknown2108
</script>
Output: 
Original Tree: 1 8 3 4 5 6 7 
Deleting node with key 8: 1 7 3 4 5 6 
Deleting node with key 1: 6 7 3 4 5 
Deleting node with key 4: 6 7 3 5

 

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :