In a Binary Tree, each node can have at most two nodes. For a binary tree to be a binary search tree (BST), the data of all the nodes in the left sub-tree of the root node should be less than or equals to the data of the root. The data of all the nodes in the right subtree of the root node should be greater than the data of the root.
Deleting a node from Binary search tree is little complicated compare to inserting a node. It includes two steps:
- Search the node with given value.
- Delete the node.
The algorithm has 3 cases while deleting node:
- Node to be deleted has is a leaf node (no children).
- Node to be deleted has one child (eight left or right child node).
- Node to be deleted has two nodes.
We will use simple recursion to find the node and delete it from the tree.
Here is the steps to delete a node from binary search tree:
Case 1: Node to be deleted has is a leaf node (no children).
- This is very simple implementation. First find the node reference with given value.
- Set corresponding link of the parent node to null. With this the node to be deleted lost its connectivity and eligible for garbage collection.
Case 2: Node to be deleted has one child (eight left or right child node).
- First find the node reference with given value.
- Take the reference of the child node and assign its reference to the corresponding link of the parent node. With this the node to be deleted lost its connectivity and eligible for garbage collection.
Case 3: Node to be deleted has two nodes.
- It is little complicated process.
- First find the node reference with given value.
- Find the minimum/maximum value of the right/left sub tree.
- Replace the node value with the minimum/maximum value.
- Now delete the minimum/maximum value from the nodes right/left sub tree.
We will use below binary tree for our code output:
BinarySearchTreeImpl
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | package com.java2novice.ds; import java.util.LinkedList; import java.util.Queue; public class BinarySearchTreeImpl { private BstNode root; public boolean isEmpty() { return (this.root == null); } public BstNode getRoot() { return this.root; } public void insert(Integer data) { System.out.print("[input: "+data+"]"); if(root == null) { this.root = new BstNode(data); System.out.println(" -> inserted: "+data); return; } insertNode(this.root, data); System.out.print(" -> inserted: "+data); System.out.println(); } private BstNode insertNode(BstNode root, Integer data) { BstNode tmpNode = null; System.out.print(" ->"+root.getData()); if(root.getData() >= data) { System.out.print(" [L]"); if(root.getLeft() == null) { root.setLeft(new BstNode(data)); return root.getLeft(); } else { tmpNode = root.getLeft(); } } else { System.out.print(" [R]"); if(root.getRight() == null) { root.setRight(new BstNode(data)); return root.getRight(); } else { tmpNode = root.getRight(); } } return insertNode(tmpNode, data); } public void delete(Integer data) { deleteNode(this.root, data); } private BstNode deleteNode(BstNode root, Integer data) { if(root == null) return root; if(data < root.getData()) { root.setLeft(deleteNode(root.getLeft(), data)); } else if(data > root.getData()) { root.setRight(deleteNode(root.getRight(), data)); } else { // node with no leaf nodes if(root.getLeft() == null && root.getRight() == null) { System.out.println("deleting "+data); return null; } else if(root.getLeft() == null) { // node with one node (no left node) System.out.println("deleting "+data); return root.getRight(); } else if(root.getRight() == null) { // node with one node (no right node) System.out.println("deleting "+data); return root.getLeft(); } else { // nodes with two nodes // search for min number in right sub tree Integer minValue = minValue(root.getRight()); root.setData(minValue); root.setRight(deleteNode(root.getRight(), minValue)); System.out.println("deleting "+data); } } return root; } private Integer minValue(BstNode node) { if(node.getLeft() != null) { return minValue(node.getLeft()); } return node.getData(); } public void inOrderTraversal() { doInOrder(this.root); } private void doInOrder(BstNode root) { if(root == null) return; doInOrder(root.getLeft()); System.out.print(root.getData()+" "); doInOrder(root.getRight()); } public static void main(String a[]) { BinarySearchTreeImpl bst = new BinarySearchTreeImpl(); bst.insert(8); bst.insert(10); bst.insert(14); bst.insert(3); bst.insert(6); bst.insert(7); bst.insert(1); bst.insert(4); bst.insert(13); System.out.println("-------------------"); System.out.println("In Order Traversal"); bst.inOrderTraversal(); System.out.println(); bst.delete(13); bst.inOrderTraversal(); System.out.println(); bst.delete(14); bst.inOrderTraversal(); } } |
BTSNode:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | package com.java2novice.ds; public class BstNode { private BstNode left; private BstNode right; private Integer data; public BstNode(Integer data) { this.data = data; } public BstNode getLeft() { return left; } public void setLeft(BstNode left) { this.left = left; } public BstNode getRight() { return right; } public void setRight(BstNode right) { this.right = right; } public Integer getData() { return data; } public void setData(Integer data) { this.data = data; } } |
Output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | [input: 8] -> inserted: 8 [input: 10] ->8 [R] -> inserted: 10 [input: 14] ->8 [R] ->10 [R] -> inserted: 14 [input: 3] ->8 [L] -> inserted: 3 [input: 6] ->8 [L] ->3 [R] -> inserted: 6 [input: 7] ->8 [L] ->3 [R] ->6 [R] -> inserted: 7 [input: 1] ->8 [L] ->3 [L] -> inserted: 1 [input: 4] ->8 [L] ->3 [R] ->6 [L] -> inserted: 4 [input: 13] ->8 [R] ->10 [R] ->14 [L] -> inserted: 13 ------------------- In Order Traversal 1 3 4 6 7 8 10 13 14 deleting 13 1 3 4 6 7 8 10 14 deleting 14 1 3 4 6 7 8 10 |
