#ifndef ___BINARY_TREE_WITH_NODE___
#define ___BINARY_TREE_WITH_NODE___

#include <iostream>

template <typename T>
class bnode
{
public:
	T data;
	bnode<T>* left, * right;

	bnode() { left = right = NULL; }
	bnode(const T& elem) { data = elem; left = right = NULL; }

	bnode<T>* treeCopy();
	void treeDeletion();
	bool find(const T& key);

	void inorder(std::ostream& out);

	void binsert(const T& elem);
	bnode<T>* bremove(const T& elem);

	T predecessor();
};


template <typename T>
class btree
{
private:
	bnode<T>* root;
public:
	btree() { root = NULL; }
	btree(btree<T>& tree2);	// copy constructor
	~btree();

	bool find(const T& key);
	void inorder(std::ostream& out);

	void binsert(const T& elem);
	void bremove(const T& elem);

};

bnode<T>* bnode<T>::treeCopy()
{
	bnode<T>* node = new bnode<T>(data);
	if (left != NULL)
		node->left = left->treeCopy();
	if (right != NULL)
		node->right = right->treeCopy();
	return node;
}

btree<T>::btree(btree<T>& tree2)
{
	if (tree2.root == NULL)
	{
		root = NULL;
		return;
	}

	root->data = tree2.root->data;
	if (tree2.root->left != NULL)
		root->left = tree2.root->left->treeCopy();
	else
		root->left = NULL;
	if (tree2.root->right != NULL)
		root->right = tree2.root->right->treeCopy();
	else
		root->right = NULL;
}

bool btree<T>::find(const T& key)
{
	if (root == NULL)
		return false;
	return root->find(key);
}

bool bnode<T>::find(const T& key)
{
	if (data == key)
		return true;
	if (key <= data)	// left subtree
	{
		if (left != NULL)
		{
			return left->find(key);
		}
		else
			return false;
	}

	if (key > data)	// right subtree
	{
		if (right != NULL)
		{
			return right->find(key);
		}
		else
			return false;
	}
}

void btree<T>::inorder(std::ostream& out)
{
	if (root == NULL)
		return;
	root->inorder(out);
}

void bnode<T>::inorder(std::ostream& out)
{
	if (left != NULL)
		left->inorder(out);
	out << data << " ";
	if (right != NULL)
		right->inorder(out);
}


void btree<T>::binsert(const T& elem)
{
	if (root == NULL)
	{
		root = new bnode<T>(elem);
		return;
	}

	root->binsert(elem);
}

void bnode<T>::binsert(const T& elem)
{
	if (elem <= data)	// insert elem into left subtree
	{
		if (left != NULL)
			left->binsert(elem);
		else
			left = new bnode<T>(elem);
	}
	else
	{
		// insert elem into right subtree
		if (right != NULL)
			right->binsert(elem);
		else
			right = new bnode<T>(elem);
	}
}

void btree<T>::bremove(const T& elem)
{
	if (root == NULL)
		return;
	root = root->bremove(elem);
}

bnode<T>* bnode<T>::bremove(const T& elem)
{
	if (data == elem)
	{
		if (left == NULL & right == NULL)
		{
			// leaf node
			delete this;
			return NULL;
		}
		if (left == NULL)
		{
			// there is one right subtree
			bnode<T>* rightsubtree = right;
			delete this;
			return rightsubtree;
		}
		if (right == NULL)
		{
			// there is one left subtree
			bnode<T>* leftsubtree = left;
			delete this;
			return leftsubtree;
		}

		// the current node has two children
		data = left->predecessor();
		left->bremove(data);
		return this;
	}
	else
	{
		if (elem <= data)
		{
			// delete elem from left subtree
			if (left != NULL)
			{
				left = left->bremove(elem);
				return this;
			}
			else
				return this;
		}
		else
		{
			// delete elem from right subtree
			if (right != NULL)
			{
				right = right->bremove(elem);
				return this;
			}
			else
				return this;
		}
	}
}

T bnode<T>::predecessor()
{
	if (right != NULL)
		return right->predecessor();
	return data;
}

#endif