# 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:

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 ``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 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 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 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 q = ``new` `LinkedList();``    ``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 q = ``new` `LinkedList();``    ``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 q = ``new` `LinkedList();``    ``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

 ``
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