// Computer Science 367, Section 3, Fall 1997
// Instructor: Michael Siff (siff@cs.wisc.edu)
//
//
// FILE: binary-tree.h
//
//
// CLASS TEMPLATE PROVIDED: 
//
//   BinaryTree<Item> - a binary tree of Items. BinaryTree<Item> is derived
//   from AbstractBinaryTree<Item>. The template parameter, Item, is the
//   data type of the items in the binary tree. It may be any of the C++
//   built-in types (int, char, etc.), or a class with a default
//   constructor, a copy constructor, and an assignment operator.
//
//
// CONSTRUCTORS for the BinaryTree<Item> template class:
//   BinaryTree(Item v)
//     Postcondition: The binary tree has been initialized as a leaf node
//     with value v.
//   BinaryTree(Item v, BinaryTree<Item> *L, BinaryTree<Item> *R) 
//     Precondition: L and R are non-overlapping binary trees. 
//     Postcondition: A binary tree has been constructed with a root of
//     value v and a left child as subtree L and right child as subtree R.
//   BinaryTree(const BinaryTree<Item>& source)
//     Postcondition: The binary tree has been initialized as a complete copy of
//     source. (This is the copy constructor.)
//
//
// DESTRUCTOR for the BinaryTree<Item> template class:
//   ~BinaryTree()
//     Postcondition: The memory allocated to store the binary tree has
//     been freed. 
//
//
// MODIFICATION MEMBER FUNCTIONS for the BinaryTree<Item> template class:
//   void operator=(const BinaryTree<Item>& source)
//     Postcondition: This tree has been assigned as a complete copy of
//     source.
//   void setVal(const Item& v) 
//     Postcondition: the value of the (node of) this tree is now v.
//   BinaryTree<Item> *setLeft(BinaryTree<Item> *T) 
//     Precondition: The right subtree has no overlap with T.
//     Postcondition: the left child of this tree is now the subtree T. The
//     return value is a pointer to the former left subtree of this tree. 
//   BinaryTree<Item> *setRight(BinaryTree<Item> *T) 
//     Precondition: the current left subtree has no overlap with T.
//     Postcondition: the right child of this tree is now the subtree T.  The
//     return value is a pointer to the former right subtree of this tree.
//
//
// CONSTANT MEMBER FUNCTIONS for the BinaryTree<Item> template class:
//   Item valOf() const
//     Postcondition: the return value is the value of the (node of) this tree.
//   BinaryTree<Item> *leftOf() const
//     Postcondition: the return value is a pointer to the left child of
//     this tree or NULL if this node has no left child.
//   BinaryTree<Item> *rightOf() const
//     Postcondition: the return value is a pointer to the right child of
//     this tree or NULL if this node has no right child.
//   BinaryTree<Item> *parentOf() const
//     Postcondition: the return value is a pointer to the parent of this
//     node or NULL if this node is the root.
//   size_t size() const
//     Postcondition: the return value is the number of nodes in the tree
//     rooted at this node.
//   size_t height() const
//     Postcondition: the return value is the height of the tree rooted at
//     this node. 
//   size_t depth() const
//     Postcondition: the return value is the depth of this node.


#ifndef BINARY_TREE_H
#define BINARY_TREE_H


template <class Item> 
class BinaryTree {
public:
  // Constructors
  BinaryTree(Item v); // create a leaf consisting of v
  BinaryTree(Item v, BinaryTree<Item> *L, BinaryTree<Item> *R); // merge
  BinaryTree(const BinaryTree<Item>& source); // copy constructor

  // Destructor
  ~BinaryTree();
  
  // Constant member functions
  size_t depth() const;
  size_t height() const;
  size_t size() const;
  Item valOf() const;
  BinaryTree<Item> *leftOf() const;
  BinaryTree<Item> *rightOf() const;
  BinaryTree<Item> *parentOf() const;

  // Modification member functions
  void operator=(const BinaryTree<Item>& source); // assignment op
  void setVal(const Item& v);
  BinaryTree<Item> *setLeft(BinaryTree<Item> *T);
  BinaryTree<Item> *setRight(BinaryTree<Item> *T);
  
private:
  Item val;
  BinaryTree<Item> *left;
  BinaryTree<Item> *right;
  BinaryTree<Item> *parent;
  // private member functions:
  void deleteTree(); 
  void copyTree(const BinaryTree<Item> *source);
};


#include "binary-tree.C"

#endif