/* Lafore, DataStructures and Algorithms in Java */

/* BST insert */

void insert (int data) {
   Node newNode = new Node();
   newNode.data = data;
   if ( root == null) root = newNode;
   else {
      Node current = root;
      Node parent;
      while (true) {
         parent = current;
         if data < current.data) {
            current = current.left;
            if (current == null) {
               parent.left = newNode;
               return;
               }
            }
         else {
         current = current.right;
         if (current == null) {
            parent.right = newNode;
            return;
            }
         }
      }												// while
   }                                      // else not root
}														// end insert()


/*  find minimum, find maximum   */

Node minimum() {
   Node current, last;
   Node current = root;
   while (current != null) {
      last = current;
      current = current.left;
      }
   return last;
}

Node maximum() {
   Node current, last;
   Node current = root;
   while (current != null) {
      last = current;
      current = current.right;
      }
   return last;
} 


/* delete  */
boolean delete (int key) {
   Node current = root;
   Node parent = root;
   boolean isLeftChild = true;
   
   while (current data != key) {
      parent = current;
      if (key < current.data) {
         isLeftChild = true;
         current = current.left;
         }
      else {
         isLeftChild = false;
         current = current.right;
         }
      if (current == null) {
         return false;
      }											// while
      
   // if no children, just delete found node
   if (current.left == null) && current.right == null) {
      if (current == root)
         root = null;
      else if (isLeft)
      	parent.left = null;
      else
      	parent.rightChild = null;
      }
      
   // one child
   // if no right child, replace with left subtree
   else if (current.right == null)
      if (current == root)
         root = current.left;
      else if (isLeftChild)
         parent.left = current.left;
      else
         parent.right = current.left;
         
   //if no left child, replace with right subtree
   else if (current.left == null)
      if (current == root)
         root = current.right;
      else if (isLeftChild)
         parent.left = current.right;
      else
         parent.right = current.right;
         
   //two children -- replace with inorder successor
   else {
      //get successor of node to delete current
      Node successor = getSuccessor (current);
      
      // connect parent of current to successor
      if (current == root)
         root = successor;
      else if (isLeftChild)
         parent.left =  successor;
      else
         parent.right = successor;
         
      // connect successor to current's left child
      successor.left = current.left;
      }												// end else
   //  successor cannot have a left child
   return true;
   }													// end delete()
   
Node getSuccessor (Node delNode) {
   Node successorParent = delNode;
   Node successor = delNode;
   Node current = delNode.right;
   while (current != null) {
      successorParent = successor;
      successor = current;
      current = current.left;
      }												// while
      
   if (successor != delNode.right) {
      successorParent.left = successor.right;
      successor.right = delNode.right;
      }
   return successor;
   }													// getSuccessor()