//########################################################
//	TREE.CPP
// 	innehåller funktioner för trädet
//========================================================

class treeClass
{
	public:
		treeClass();
		~treeClass(){};
		ptrType root;
		ptrType seek(ptrType root, dataType item);
		bool isEmpty();
		void insert(ptrType &root,dataType item);
		void del(ptrType &root,dataType item);
		void delRoot(ptrType &root);
		void delLeft(ptrType &root, dataType &item);
		void preOrder(ptrType treeNode);
		void inOrder(ptrType treeNode);
		void postOrder(ptrType treeNode);
		void save(ptrType root, fstream &fil);
};
//########################################################
//	SKAPAR ETT TRÄD & SÄTTER ROOT TILL NULL
//========================================================
treeClass::treeClass():root(NULL)
{
}
//########################################################
//	SKAPAR EN NOD
//========================================================
treeNode::treeNode(dataType item, ptrType L, ptrType R):data(item),left(L),right(R)
{
}
//########################################################
//	KOLLAR OM DET FINNS NODER I TRÄDET
//		pre: TRUE
//		post: TRUE om trädet är tomt
//		post: FALSE om det finns noder i trädet
//========================================================
bool treeClass::isEmpty()
{
	if (root==NULL)
		return TRUE;
	else
		return FALSE;
}
//########################################################
//	SKRIVER UT TRÄDET I PREORDER
//		pre: att trädet inte är tomt
//		post: trädet har skrivits ut i preOrder
//		calls: preOrder (rekursivt)
//========================================================
void treeClass::preOrder(ptrType treeNode)
{
	if(treeNode)
	{
		cout  << " ";
		cout << treeNode->data;
		preOrder(treeNode->left);
		preOrder(treeNode->right);
	}
}
//########################################################
//	SKRIVER UT TRÄDET I INORDER
//		pre: att trädet inte är tomt
//		post: trädet har skrivits ut i inOrder
//		calls: inOrder (rekursivt)
//========================================================
void treeClass::inOrder(ptrType treeNode)
{
	if(treeNode)
	{
		inOrder(treeNode->left);
		cout << treeNode->data << " ";
		inOrder(treeNode->right);
	}
}
//########################################################
//	SKRIVER UT TRÄDET I POSTORDER
//		pre: att trädet inte är tomt
//		post: trädet har skrivits ut i postOrder
//		calls: postOrder (rekursivt)
//========================================================
void treeClass::postOrder(ptrType treeNode)
{
	if(treeNode)
	{
		postOrder(treeNode->left);
		postOrder(treeNode->right);
		cout << treeNode->data << " ";
	}
}
//########################################################
// SÖKER EFTER ETT ELEMENT I TRÄDET
//		pre: att trädet inte är tomt
//		post: NULL om noden inte fanns
//		post: sökta värdet om värdet fanns
//		calls: seek (rekursivt)
//========================================================
ptrType treeClass::seek(ptrType root, dataType item)
{
	ptrType treeNodeFound;
	if(root == NULL)
		treeNodeFound = NULL;
	else if (root->data == item)
		treeNodeFound = root;
	else if (root->data > item)
		treeNodeFound = seek(root->left, item);
	else
		treeNodeFound = seek(root->right, item);
	return treeNodeFound;
}
//########################################################
// SÄTTER IN EN NOD I TRÄDET
//		pre: att inmatningen är ett heltal
//		post: trädet har fått en ny nod insatt
//				 på rätt plats i trädet.
//		calls: insert (rekursivt)
//========================================================
void treeClass::insert(ptrType &root,dataType item)
{
	if(root==NULL)
		root=new treeNode(item,NULL,NULL);
	else if(item < root->data)
		insert(root->left,item);
	else
		insert(root->right,item);
}
//########################################################
// TAR BORT EN NODEN TILL VÄNSTER
//		pre: att det finns ett träd
//		pre: att noden finns
//		post: noden har tagits ur trädet och
//				de andra noderna sitter nu rätt placerade
//		calls: delLeft (rekursivt)
//========================================================
void treeClass::delLeft(ptrType &root, dataType &item)
{
	if((root != NULL) && (root->left == NULL))
	{
		item = root->data;
		ptrType delPtr = root;
		root = root->right;
		delPtr->right = NULL;
		delete delPtr;
	}
	else
		delLeft(root->left, item);
}
//########################################################
// TAR BORT NODEN OM DEN ÄR EN ROT
//		pre: att det finns ett träd
//		pre: att noden finns
//		post: noden har tagits ur trädet och
//				de andra noderna sitter nu rätt placerade
//========================================================
void treeClass::delRoot(ptrType &root)
{
	ptrType delPtr;
	dataType nyItem;

	if(root != NULL)
	{
		if((root->left == NULL) && (root->right == NULL))
		{
			delete root;
			root = NULL;
		}
		else if(root->left == NULL)
		{
			delPtr = root;
			root = root->right;
			delPtr->right = NULL;
			delete delPtr;
		}
		else if(root->right == NULL)
		{
			delPtr = root;
			root = root->left;
			delPtr->left = NULL;
			delete delPtr;
		}
		else
		{
			delLeft(root->right, nyItem);
			root->data = nyItem;
		}
	}
}
//########################################################
// TAR BORT EN NOD UR TRÄDET
//		pre: att det finns ett träd
//		pre: att noden finns
//		post: noden har tagits ur trädet och
//				de andra noderna sitter nu rätt placerade
//		calls: delRoot om noden är en rot
//		calls: del (rekursivt)
//========================================================
void treeClass::del(ptrType &root, dataType item)
{
	if(item==root->data)
		delRoot(root);
	else if(item < root->data)
		del(root->left, item);
	else
		del(root->right,item);
}
//########################################################
// SPARAR TRÄDET PÅ FIL
//		läser av nodens värde i alla noder i
//		preorder och skriver de på filen.
//		pre: att det finns ett träd
//		post: trädet har sparats på fil
//		calls: save (rekursivt)
//========================================================
void treeClass::save(ptrType root, fstream &fil)
{
	if(root)
	{
		fil.write((char*)&root->data,sizeof(root));
		save(root->left,fil);
		save(root->right,fil);
	}
}