// Source code example for "A Practical Introduction
// to Data Structures and Algorithm Analysis"
// by Clifford A. Shaffer, Prentice Hall, 1998.
// Copyright 1998 by Clifford A. Shaffer
// modified by X. Meng for class demonstration
// added a in-order visit to show the order
// of the elements in a BST
// dec-07-1998

class BST { // Binary Search Tree implementation
  private BinNode root;                // The root of the tree

  public BST() { root = null; }        // Initialize root to null
  public void clear() { root = null; } // Throw the nodes away
  public void insert(Elem val) { root = inserthelp(root, val); }
  public void remove(int key) { root = removehelp(root, key); }
  public Elem find(int key) { return findhelp(root, key); }
  public boolean isEmpty() { return root == null; }

  public void print() { // Print out the BST
    if (root == null)
      System.out.println("The BST is empty.");
    else {
      printhelp(root, 0);
      System.out.println();
    }
  }

  /** added by X. Meng dec-07-1998 **/
  public void printOrder() // print tree in order
  {
      inOrder(root);
      System.out.println();
  }

  /** added by X. Meng dec-07-1998 **/
  private void inOrder(BinNode ptr)
  {
      if (ptr != null)
      {
	  inOrder(ptr.left());
	  System.out.print(ptr.element() + " ");
	  inOrder(ptr.right());
      }
  }

  private Elem findhelp(BinNode rt, int key) {
      if (rt == null) return null;
      Elem it = (Elem)rt.element();
      if (it.key() > key)  return findhelp(rt.left(), key);
      else if (it.key() == key)  return it;
      else  return findhelp(rt.right(), key);
  }
  private BinNode inserthelp(BinNode rt, Elem val) {
      if (rt == null) return new BinNodePtr(val);
      Elem it = (Elem)rt.element();
      if (it.key() > val.key())
	  rt.setLeft(inserthelp(rt.left(), val));
      else
	  rt.setRight(inserthelp(rt.right(), val));
      return rt;
  }
  private BinNode deletemin(BinNode rt) {
      if (rt.left() == null)
	  return rt.right();
      else {
	  rt.setLeft(deletemin(rt.left()));
	  return rt;
      }
  }
  private Elem getmin(BinNode rt) {
      if (rt.left() == null)
	  return (Elem)rt.element();
      else return getmin(rt.left());
  }
  private BinNode removehelp(BinNode rt, int key) {
      if (rt == null) return null;
      Elem it = (Elem)rt.element();
      if (key < it.key())
	  rt.setLeft(removehelp(rt.left(), key));
      else if (key > it.key())
	  rt.setRight(removehelp(rt.right(), key));
      else { // Found it
	  if (rt.left() == null)
	      rt = rt.right();
	  else if (rt.right() == null)
	      rt = rt.left();
	  else { // Two children
	      Elem temp = getmin(rt.right());
	      rt.setElement(temp);
	      rt.setRight(deletemin(rt.right()));
	  }
      }
      return rt;
  }
  private void printhelp(BinNode rt, int level) {
      if (rt == null) return;
      printhelp(rt.left(), level+1);
      for (int i=0; i<level; i++)     // Indent based on level
	  System.out.print("  ");
      System.out.println((Elem)rt.element()); // Print node value
      printhelp(rt.right(), level+1);
  }
  void preorder(BinNode rt) // rt is the root of the subtree
  {
      if (rt == null) return; // Empty subtree
      visit(rt);
      preorder(rt.left());
      preorder(rt.right());
  }
  
  public void pre() {
      preorder(root);
      System.out.println();
  }
  
  private void visit(BinNode rt) {
      System.out.print(rt.element() + " ");
  }
}