//  File: bstree.C
//
//  A binary search tree class

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "bstree.h"


// ========================================================
// BSTreeNode member functions

// Constructors

template <class TYPE>
BSTreeNode<TYPE>::BSTreeNode() {}


template <class TYPE>
BSTreeNode<TYPE>::BSTreeNode(const TYPE& t) 
:  data(t) {}


template <class TYPE>
BSTreeNode<TYPE>::BSTreeNode(
   const TYPE& t, const BSTree<TYPE>& lt, const BSTree<TYPE>& rt)
:  data(t), left(lt), right(rt) {}


template <class TYPE>
BSTreeNode<TYPE>::~BSTreeNode() {
#ifndef NDEBUG
   cout << "Destroying node with data = " << data << endl ;
#endif
}


template <class TYPE>
void *BSTreeNode<TYPE>::operator new(size_t n) {

   void *ptr ;
   MemoryError e ;

   ptr = malloc(n) ;
   if (ptr == NULL) throw(e) ;

   return ptr ;
}


template <class TYPE>
void BSTreeNode<TYPE>::operator delete(void *ptr) {
   
   if (ptr == NULL) return ;
   free(ptr) ;
}


// ========================================================
// BSTree member functions


// Constructor
//
template <class TYPE>
BSTree<TYPE>::BSTree() {
   root = NULL ;
}


// Destructor (Beware!)
//
template <class TYPE>
BSTree<TYPE>::~BSTree() {
   delete root ;
}


// Inorder Traversal of a BSTree
//
template <class TYPE>
void BSTree<TYPE>::inorder() {

   if (root == NULL) return ;

   cout << "(" ;
   root->left.inorder() ;
   cout << " " << root->data << " " ;
   root->right.inorder() ;
   cout << ")" ;
}


// Insert functions
//
template <class TYPE>
void BSTree<TYPE>::insert(const TYPE& t) {

   if (root == NULL) {
      root = new BSTreeNode<TYPE>(t) ;
      return ;
   }

   if (t <= root->data) {
      root->left.insert(t) ;
   } else {
      root->right.insert(t) ;
   }
}


// returns pointer to BSTree where the root has key value == x.
// returns NULL, if no such node.
//
template <class TYPE>
BSTree<TYPE> *BSTree<TYPE>::find(const TYPE& t) {
   if (root == NULL) return NULL ;

   if (t == root->data) {
      return this ;
   } else if (t < root->data) {
      return root->left.find(t) ;
   } else {
      return root->right.find(t) ;
   }
}


// Removes the root node of host subtree.  Can be used in conjunction
// with Search.
//
template <class TYPE>
void BSTree<TYPE>::removeroot() {
   BSTreeNode<TYPE> *temp ;

   if (root == NULL) return ;

   // Otherwise, we have found x
   temp = deleteroot() ;

   // temp should be cleaned up
   assert(temp->left.root == NULL) ;
   assert(temp->right.root == NULL) ;

   delete temp ;
}


// returns pointer to BSTree where the root has min key value.
// returns NULL if BSTree is empty.
//
template <class TYPE>
BSTree<TYPE> *BSTree<TYPE>::min() {
   if (root == NULL) return NULL ;

   if (root->left.root == NULL) { // found min
      return this ;
   } else {
      return root->left.min() ;
   }
}


// returns pointer to BSTree where the root has max key value.
// returns NULL if BSTree is empty.
//
template <class TYPE>
BSTree<TYPE> *BSTree<TYPE>::max() {
   if (root == NULL) return NULL ;

   if (root->right.root == NULL) { // found max
      return this ;
   } else {
      return root->right.max() ;
   }
}


// Returns 1 if tree is empty, returns 1 otherwise
//
template <class TYPE>
bool BSTree<TYPE>::empty() {

   return root == NULL ? true : false ;
}


template <class TYPE>
void *BSTree<TYPE>::operator new(size_t n) {

   void *ptr ;
   MemoryError e ;

   ptr = malloc(n) ;
   if (ptr == NULL) throw(e) ;

   return ptr ;
}


template <class TYPE>
void BSTree<TYPE>::operator delete(void* ptr) {

   if (ptr == NULL) return ;
   free(ptr) ;
}




// Protected member functions


// Removes BSTreeNode with smallest key and returns a pointer
// to the node. Returned pointer must be freed after use.
//
template <class TYPE>
BSTreeNode<TYPE> *BSTree<TYPE>::deletemin() {
   BSTreeNode<TYPE> *answer ;

   if (root == NULL) return NULL ;

   if (root->left.root == NULL) { // found min
      answer = root ;
      root = root->right.root ;
      answer->right.root = NULL ;
      return answer ;
   } else {
      return root->left.deletemin() ;
   }
}


// Removes BSTreeNode at the root and returns a pointer to.
// the root.  Returned pointer must be freed after use.
//
template <class TYPE>
BSTreeNode<TYPE> *BSTree<TYPE>::deleteroot() {
   BSTreeNode<TYPE> *answer, *temp ;

   answer = root ;

   // Easy Case 1: tree is a single node
   if (root->left.root == NULL && root->right.root == NULL) {
      root = NULL ;
      return answer ;
   }

   // Easy Case 2: tree has no left child
   if (root->left.root == NULL) {
      root = root->right.root ;
      answer->right.root = NULL ; // fix up answer
      return answer ;
   }

   // Easy Case 3: tree has no right child
   if (root->right.root == NULL) {
      root = root->left.root ;
      answer->left.root = NULL ; // fix up answer
      return answer ;
   }

   // Hard Case: tree has both left and right childern
   temp = root->right.deletemin() ;

   // make temp new root
   temp->left = root->left ;
   temp->right = root->right ;
   root = temp ;

   // fix up answer
   answer->left.root = NULL ;
   answer->right.root = NULL ;
   return answer ;
}