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

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: 
 

Input: K = 8, Tree = 
 

Output: 
 



Explanation: 
Please Refer below for explanation.
Input: K = 1, Tree = 
 

Output: 
 

 

 

Approach: 
 

For example: Consider the Example 1 from above 
 

Below is the implementation of the above approach.
 

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

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

 

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.





Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : anshulgtbit91

Article Tags :
Practice Tags :