// Oldham, Jeffrey D.
// 2000Apr09
// CS1321

// Binary Search Trees

// These binary search tree routines are defined recursively since we
// are using recursively defined trees.

#include <iostream>
#include <stdlib.h>		// has EXIT_SUCCESS
#include <assert.h>
#include "tree.h"

// Return a tree including the given item.
// If the item is already in the tree, the tree is unchanged.
// We assume < is defined for ItemType.
template <class ItemType>
Tree<ItemType> insert(const ItemType & i, const Tree<ItemType> & t) {
  if (t.empty())
    return Tree<ItemType>(i, Tree<ItemType>(), Tree<ItemType>());
  else {// nonempty tree
    if (i < t.item())
      return Tree<ItemType>(t.item(), insert(i, t.left()), t.right());
    else if (t.item() < i)
      return Tree<ItemType>(t.item(), t.left(), insert(i, t.right()));
    else // i == t.item() so already in the tree
      return t;
  }
}


// Query whether the given item is in the tree.
// We assume < is defined for ItemType.
template <class ItemType>
bool query(const ItemType & i, const Tree<ItemType> & t) {
  if (t.empty())
    return false;
  else {// nonempty tree
    if (i < t.item())
      return query(i, t.left());
    else if (t.item() < i)
      return query(i, t.right());
    else // i == t.item()
      return true;
  }
}


// Print the tree's contents.
template <class ItemType>
ostream& operator<<(ostream & out, const Tree<ItemType> & t) {
  if (t.empty())
    return out;
  else {// nonempty tree
    return out << t.left() << t.item() << endl << t.right();
  }
}


// Delete the specified item if present in the tree.  If the item is
// not present, the tree remains unchanged.  A nontraditional design
// decision: If both subtrees of a root are present, we choose which
// subtree to modify using a random coin toss.

// helper functions
// input <- nonempty tree
// output-> tree without its maximum element
//	    maximum element
template <class ItemType>
Tree<ItemType> removeMax(const Tree<ItemType> & t, ItemType &max) {
  assert(t);			// not empty
  if (t.right().empty()) { // no right subtree
    max = t.item();
    return t.left();
  }
  else // nonempty right subtree
    return Tree<ItemType>(t.item(), t.left(), removeMax(t.right(), max));
}

// input <- nonempty tree
// output-> tree without its minimum element
//	    minimum element
template <class ItemType>
Tree<ItemType> removeMin(const Tree<ItemType> & t, ItemType &min) {
  assert(t);			// not empty
  if (t.left().empty()) { // no left subtree
    min = t.item();
    return t.right();
  }
  else // nonempty left subtree
    return Tree<ItemType>(t.item(), removeMin(t.left(), min), t.right());
}

template <class ItemType>
Tree<ItemType> remove(const ItemType & i, const Tree<ItemType> & t) {
  if (t.empty())
    return t;
  else {// nonempty tree
    if (i < t.item())
      return Tree<ItemType>(t.item(), remove(i, t.left()), t.right());
    else if (t.item() < i)
      return Tree<ItemType>(t.item(), t.left(), remove(i, t.right()));
    else { // i == t.item().  Need to find a nonempty subtree.
      if (t.left().empty())
	return t.right();
      else if (t.right().empty())
	return t.left();
      else { // Both subtrees not empty so flip coin to decide which to change.
	if (rand() / static_cast<double>(RAND_MAX) * 2 >= 1) {
	  ItemType itm;
	  Tree<ItemType> tr = removeMax(t.left(), itm);
	  return Tree<ItemType>(itm, tr, t.right());
	}
	else {
	  ItemType itm;
	  Tree<ItemType> tr = removeMin(t.right(), itm);
	  return Tree<ItemType>(itm, t.left(), tr);
	}
      }
    }
  }
}