JAVA EXAMPLE PROGRAMS

JAVA EXAMPLE PROGRAMS

Publish Your Article Here

Program: How to delete a node from Binary Search Tree (BST)?


Description:

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:

  1. Search the node with given value.
  2. Delete the node.

The algorithm has 3 cases while deleting node:

  1. Node to be deleted has is a leaf node (no children).
  2. Node to be deleted has one child (eight left or right child node).
  3. 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).

  1. This is very simple implementation. First find the node reference with given value.
  2. 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).

  1. First find the node reference with given value.
  2. 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.

  1. It is little complicated process.
  2. First find the node reference with given value.
  3. Find the minimum/maximum value of the right/left sub tree.
  4. Replace the node value with the minimum/maximum value.
  5. Now delete the minimum/maximum value from the nodes right/left sub tree.

We will use below binary tree for our code output:

Binary Search Tree


BinarySearchTreeImpl
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();
	}
}

BstNode
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:
[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 
<< Previous Program 

List Of All Interview Programs:

  1. How to reverse Singly Linked List?
  2. Find out duplicate number between 1 to N numbers.
  3. Find out middle index where sum of both ends are equal.
  4. Write a singleton class.
  5. Write a program to create deadlock between two threads.
  6. Write a program to reverse a string using recursive algorithm.
  7. Write a program to reverse a number.
  8. Write a program to convert decimal number to binary format.
  9. Write a program to find perfect number or not.
  10. Write a program to implement ArrayList.
  11. Write a program to find maximum repeated words from a file.
  12. Wrie a program to find out duplicate characters in a string.
  13. Write a program to find top two maximum numbers in a array.
  14. Write a program to sort a map by value.
  15. Write a program to find common elements between two arrays.
  16. How to swap two numbers without using temporary variable?
  17. Write a program to print fibonacci series.
  18. Write a program to find sum of each digit in the given number using recursion.
  19. Write a program to check the given number is a prime number or not?
  20. Write a program to find the given number is Armstrong number or not?
  21. Write a program to convert binary to decimal number.
  22. Write a program to check the given number is binary number or not?
  23. Write a program for Bubble Sort in java.
  24. Write a program for Insertion Sort in java.
  25. Write a program to implement hashcode and equals.
  26. How to get distinct elements from an array by avoiding duplicate elements?
  27. Write a program to get distinct word list from the given file.
  28. Write a program to get a line with max word count from the given file.
  29. Write a program to convert string to number without using Integer.parseInt() method.
  30. Write a program to find two lines with max characters in descending order.
  31. Write a program to find the sum of the first 1000 prime numbers.
  32. Find longest substring without repeating characters.
  33. Write a program to remove duplicates from sorted array.
  34. How to sort a Stack using a temporary Stack?
  35. Write a program to print all permutations of a given string.
  36. Implement Binary Search Tree (BST)
  37. Find min and max value from Binary Search Tree (BST)
  38. Find height of a Binary Search Tree (BST)
  39. Implement Binary Search Tree (BST) Level order traversal (breadth first).
  40. Implement Binary Search Tree (BST) pre-order traversal (depth first).
  41. Implement Binary Search Tree (BST) in-order traversal (depth first).
  42. Implement Binary Search Tree (BST) post-order traversal (depth first).
  43. How to check the given Binary Tree is Binary Search Tree (BST) or not?
  44. How to delete a node from Binary Search Tree (BST)?
Knowledge Centre
What is fail-fast in java?
A fail-fast system is nothing but immediately report any failure that is likely to lead to failure. When a problem occurs, a fail-fast system fails immediately. In Java, we can find this behavior with iterators. Incase, you have called iterator on a collection object, and another thread tries to modify the collection object, then concurrent modification exception will be thrown. This is called fail-fast.
Famous Quotations
Discipline is just choosing between what you want now and what you want most.
-- Unknown Author

About Author

I'm Nataraja Gootooru, programmer by profession and passionate about technologies. All examples given here are as simple as possible to help beginners. The source code is compiled and tested in my dev environment.

If you come across any mistakes or bugs, please email me to [email protected].

Most Visited Pages

Other Interesting Sites

Reference: Java™ Platform Standard Ed. 7 - API Specification | Java™ Platform Standard Ed. 8 - API Specification | Java is registered trademark of Oracle.
Privacy Policy | Copyright © 2018 by Nataraja Gootooru. All Rights Reserved.