#ifndef ___BINARY__TREE__
#define ___BINARY__TREE__

#include <iostream>
#include <cassert>

template <typename T>
class btree
{
private:
	T data;
	bool empty;
	btree<T>* left, * right;

public:
	btree() { empty = true; left = right = NULL; }
	btree(const T& elem) 
	{ 
		data = elem; 
		empty = false; 
		left = right = NULL; 
	}

	btree(const btree<T>& tree2);		// copy constructor
	~btree();

	void swap(btree<T>& tree2);

	void binsert(const T& elem);

	bool find(T& elem);

	void inorder(std::ostream& out);
	void preorder(std::ostream& out);
	void postorder(std::ostream& out);

};

template <typename T>
void btree<T>::swap(btree<T>& tree2)
{
	T tmp_data = data;
	data = tree2.data;
	tree2.data = tmp_data;

	// left subtree
	btree<T>* tmp_ptr = left;
	left = tree2.left;
	tree2.left = tmp_ptr;

	// right subtree
	btree<T>* tmp_ptr = right;
	right = tree2.right;
	tree2.right = tmp_ptr;

}

template <typename T>
void btree<T>::binsert(const T& elem)
{
	if (empty == true)
	{
		data = elem;
		empty = false;
		return;
	}

	if (elem <= data)	// elem should be inserted into the left subtree
	{
		if (left == NULL)
		{
			left = new btree<T>(elem);
		}
		else
			left->binsert(elem);
		return;
	}

	if (elem > data)	// elem should be inserted into the right subtree
	{
		if (right == NULL)
		{
			right = new btree<T>(elem);
		}
		else
			right->binsert(elem);
	}
}

template <typename T>
btree<T>::btree(const btree<T>& tree2)		// copy constructor
{
	data = tree2.data;
	empty = tree2.empty;
	left = right = NULL;

	if (tree2.left != NULL)
	{
		// tree2 has left subtree
		left = new btree<T>(*(tree2.left));
	}

	if (tree2.right != NULL)
	{
		// tree2 has right subtree
		right = new btree<T>(*(tree2.right));
	}
}

template <typename T>
btree<T>::~btree()
{
	if (left != NULL)
		delete left;
	if (right != NULL)
		delete right;
}

template <typename T>
bool btree<T>::find(T& key)
{
	if (empty == true)
	{
		return false;
	}
	
	if (key == data)
		return true;

	if (key <= data)	// key might exist in the left subtree
	{
		if (left == NULL)
			return false;
		else
			return left->find(key);	
	}

	if (key > data)		// key might exist in the right subtree
	{
		if (right == NULL)
			return false;
		else
			return right->find(key);
	}

}

template <typename T>
void btree<T>::inorder(std::ostream& out)
{
	if (empty == true)
	{
		return;
	}

	if (left != NULL)
	{
		left->inorder(out);
	}

	out << data << " ";

	if (right!= NULL)
	{
		right->inorder(out);
	}
}

template <typename T>
void btree<T>::preorder(std::ostream& out)
{
	if (empty == true)
	{
		return;
	}

	out << data << " ";

	if (left != NULL)
	{
		left->preorder(out);
	}

	if (right != NULL)
	{
		right->preorder(out);
	}
}

template <typename T>
void btree<T>::postorder(std::ostream& out)
{
	if (empty == true)
	{
		return;
	}

	if (left != NULL)
	{
		left->postorder(out);
	}

	if (right != NULL)
	{
		right->postorder(out);
	}

	out << data << " ";
}

#endif