Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Create BINARY SEARCH TREE #1640

Open
wants to merge 18 commits into
base: dev
Choose a base branch
from
Open

Create BINARY SEARCH TREE #1640

wants to merge 18 commits into from

Conversation

akhil1810
Copy link

public class BinarySearchTree {

//Represent a node of binary tree  
public static class Node{  
    int data;  
    Node left;  
    Node right;  

    public Node(int data){  
        //Assign data to the new node, set left and right children to null  
        this.data = data;  
        this.left = null;  
        this.right = null;  
    }  
  }  

  //Represent the root of binary tree  
  public Node root;  

  public BinarySearchTree(){  
      root = null;  
  }  

  //insert() will add new node to the binary search tree  
  public void insert(int data) {  
      //Create a new node  
      Node newNode = new Node(data);  

      //Check whether tree is empty  
      if(root == null){  
          root = newNode;  
          return;  
        }  
      else {  
          //current node point to root of the tree  
          Node current = root, parent = null;  

          while(true) {  
              //parent keep track of the parent node of current node.  
              parent = current;  

              //If data is less than current's data, node will be inserted to the left of tree  
              if(data < current.data) {  
                  current = current.left;  
                  if(current == null) {  
                      parent.left = newNode;  
                      return;  
                  }  
              }  
              //If data is greater than current's data, node will be inserted to the right of tree  
              else {  
                  current = current.right;  
                  if(current == null) {  
                      parent.right = newNode;  
                      return;  
                  }  
              }  
          }  
      }  
  }  

//minNode() will find out the minimum node
public Node minNode(Node root) {
if (root.left != null)
return minNode(root.left);
else
return root;
}

  //deleteNode() will delete the given node from the binary search tree  
  public Node deleteNode(Node node, int value) {  
      if(node == null){  
          return null;  
       }  
      else {  
          //value is less than node's data then, search the value in left subtree  
          if(value < node.data)  
              node.left = deleteNode(node.left, value);  

          //value is greater than node's data then, search the value in right subtree  
          else if(value > node.data)  
              node.right = deleteNode(node.right, value);  

          //If value is equal to node's data that is, we have found the node to be deleted  
          else {  
              //If node to be deleted has no child then, set the node to null  
              if(node.left == null && node.right == null)  
                  node = null;  

              //If node to be deleted has only one right child  
              else if(node.left == null) {  
                  node = node.right;  
              }  

              //If node to be deleted has only one left child  
              else if(node.right == null) {  
                  node = node.left;  
              }  

              //If node to be deleted has two children node  
              else {  
                  //then find the minimum node from right subtree  
                  Node temp = minNode(node.right);  
                  //Exchange the data between node and temp  
                  node.data = temp.data;  
                  //Delete the node duplicate node from right subtree  
                  node.right = deleteNode(node.right, temp.data);  
              }  
          }  
          return node;  
      }  
  }  

  //inorder() will perform inorder traversal on binary search tree  
  public void inorderTraversal(Node node) {  

      //Check whether tree is empty  
      if(root == null){  
          System.out.println("Tree is empty");  
          return;  
       }  
      else {  

          if(node.left!= null)  
              inorderTraversal(node.left);  
          System.out.print(node.data + " ");  
          if(node.right!= null)  
              inorderTraversal(node.right);  

      }  
  }  

public static void main(String[] args) {

      BinarySearchTree bt = new BinarySearchTree();  
      //Add nodes to the binary tree  
      bt.insert(50);  
      bt.insert(30);  
      bt.insert(70);  
      bt.insert(60);  
      bt.insert(10);  
      bt.insert(90);  

      System.out.println("Binary search tree after insertion:");  
      //Displays the binary tree  
      bt.inorderTraversal(bt.root);  

      Node deletedNode = null;  
      //Deletes node 90 which has no child  
      deletedNode = bt.deleteNode(bt.root, 90);  
      System.out.println("\nBinary search tree after deleting node 90:");  
      bt.inorderTraversal(bt.root);  

      //Deletes node 30 which has one child  
      deletedNode = bt.deleteNode(bt.root, 30);  
      System.out.println("\nBinary search tree after deleting node 30:");  
      bt.inorderTraversal(bt.root);  

      //Deletes node 50 which has two children  
      deletedNode = bt.deleteNode(bt.root, 50);  
      System.out.println("\nBinary search tree after deleting node 50:");  
      bt.inorderTraversal(bt.root);  
  }  

}

@akhil1810 akhil1810 changed the title BINARY SEARCH TREE Create BINARY SEARCH TREE Oct 1, 2022
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

2 participants