#ifndef __BS_TREE_WITH_NODES_HPP__
#define __BS_TREE_WITH_NODES_HPP__

#include <iostream>
#include <cassert>


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

	bnode() { left = right = NULL; }
	bnode(const T& x) { data = x; left = right = NULL;}
	bnode(const bnode<T>& node2);	// copy constructor
	~bnode();

	bool find(const T& key) const;
	void binsert(const T& key);
	bnode<T> * bremove(const T& key);

	void inorder(std::ostream& out);
	T predecessor() const;
};


template <typename T>
class btree
{
private:
	bnode<T>* root;
public:

	btree() { root = NULL; }
	btree(const btree<T>& tree2);
	~btree();

	bool find(const T& key) const;
	void binsert(const T& key);
	void bremove(const T& key);

	void inorder(std::ostream& out);
};

template <typename T>
btree<T>::btree(const btree<T>& tree2)
{
	root = NULL;

	if (tree2.root != NULL)
	{
		root = new bnode<T>(*(tree2.root));
	}

}

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

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

template <typename T>
bnode<T>::bnode(const bnode<T>& node2) 
{
	data = node2.data; 
	left = right = NULL;

	if (node2.left != NULL)
	{
		left = new bnode<T>(*(node2.left));
	}
	if (node2.right != NULL)
	{
		right = new bnode<T>(*(node2.right));
	}
}


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

template <typename T>
bool bnode<T>::find(const T& key) const
{
	if (data == key)
		return true;

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

template <typename T>
void btree<T>::binsert(const T& key)
{
	// tree is empty
	if (root == NULL)
	{
		root = new bnode<T>(key);
		return;
	}

	root->binsert(key);
}

template <typename T>
void bnode<T>::binsert(const T& key)
{
	if (key <= data)
	{
		// insertion into left subtree
		if (left == NULL)
		{
			left = new bnode<T>(key);
		}
		else
		{
			left->binsert(key);
		}
	}
	else
	{
		// insertion into right subtree
		if (right == NULL)
		{
			right = new bnode<T>(key);
		}
		else
		{
			right->binsert(key);
		}
	}
}

template <typename T>
T bnode<T>::predecessor() const
{
	if (right == NULL)
		return data;
	else
	{
		return right->predecessor();
	}
}

template <typename T>
void btree<T>::bremove(const T& key)
{
	if (find(key) == true)
		root->bremove();
}

template <typename T>
bnode<T>* bnode<T>::bremove(const T& key)
{
	if (key == data)
	{
		if (left == NULL && right == NULL)
		{
			delete this;
			return NULL;
		}
		if (left != NULL && right == NULL)	// left subtree only
		{
			bnode<T>* temp = left;
			left = NULL;	// important
			delete this;
			return temp;
		}
		if (left == NULL && right != NULL)	// right subtree only
		{
			bnode<T>* temp = right;
			right = NULL;	// important
			delete this;
			return temp;
		}
		if (left != NULL && right != NULL)
		{
			T x = left->predecessor();
			data = x;
			left->bremove(x);
			return this;
		}
	}
	else
	{
		if (key <= data)
		{
			left = left->bremove(key);
		}
		else
		{
			right = right->bremove(key);
		}
		return this;
	}
}

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

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

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

#endif