TimeDomainRCS/n2f_FAST/tree.h

// TREE.H: Definition of template class Tree
#ifndef TREE_H
#define TREE_H
#include <iostream>
#include <assert.h>

template<class NODETYPE>
class TreeNode {
public: 
  NODETYPE data;

  TreeNode(const NODETYPE &); // constructor
  NODETYPE getData() const; // return data
  NODETYPE *getDataPtr(); // return the pointer to data

  TreeNode *leftPtr; // pointer to left subtree
  TreeNode *rightPtr; // pointer to right subtree  
};


// constructor
template<class NODETYPE>
TreeNode<NODETYPE>::TreeNode(const NODETYPE &d)
{
  data = d;
  leftPtr = rightPtr = 0;
}

// Return a copy of the data value
template<class NODETYPE>
NODETYPE TreeNode<NODETYPE>::getData() const { return data; }

// Return a copy of the data value
template<class NODETYPE>
NODETYPE *TreeNode<NODETYPE>::getDataPtr() { return &data; }

template<class NODETYPE>
class Tree {
public:
  Tree();
  ~Tree();

  TreeNode<NODETYPE> * insertNode(const NODETYPE &);
  void preOrderTraversal() const;
  TreeNode<NODETYPE> *findNode(const NODETYPE &);

  // set functions
  void ConvertToArray(NODETYPE **, int);

  // get counter
  int getcounter();
  void freeMemory(void);
private:
void FREE(TreeNode<NODETYPE>*);
  TreeNode<NODETYPE>* rootPtr;
  int counter, id;

  // utility functions
  TreeNode<NODETYPE>* insertNodeHelper(TreeNode<NODETYPE>**, const NODETYPE &);
  TreeNode<NODETYPE>* findNodeHelper(TreeNode<NODETYPE>*, const NODETYPE &);
  void preOrderHelper(TreeNode<NODETYPE>*) const;
  void convertToarrayHelper(TreeNode<NODETYPE>* , NODETYPE **);
};

template<class NODETYPE>
Tree<NODETYPE>::Tree() { rootPtr = 0; counter = 0; }
template<class NODETYPE>
		Tree<NODETYPE>::~Tree() 
{ 
// 	if(counter==0||rootPtr==0)
// 		return;
// 	else
// 	{
// 		FREE(rootPtr);
// 		delete rootPtr;
// 		return;
// 	} 
}
template<class NODETYPE> void 
		Tree<NODETYPE>::freeMemory(void)
{
	if(counter==0||rootPtr==0)
		return;
	else
	{
		FREE(rootPtr);
		delete rootPtr;
		return;
	} 
} 
template<class NODETYPE>
		void Tree<NODETYPE>::FREE(TreeNode<NODETYPE> *P) 
{ 
	if(P->leftPtr!=NULL)
	{
		FREE(P->leftPtr);
		delete P->leftPtr;
	}
	if(P->rightPtr!=NULL)
	{
		FREE(P->rightPtr);
		delete P->rightPtr;
	}
	
	return;
}
template<class NODETYPE>
TreeNode<NODETYPE> * Tree<NODETYPE>::insertNode(const NODETYPE &value)
{ 
  return insertNodeHelper(&rootPtr, value); 
}

// This function receives a pointer to a pointer so the
// pointer can be modified
template<class NODETYPE>
TreeNode<NODETYPE>* Tree<NODETYPE>::insertNodeHelper(TreeNode<NODETYPE> **ptr,
				      const NODETYPE &value)
{
  if (*ptr == 0) {
    *ptr = new TreeNode<NODETYPE>(value);
    counter ++;
	return *ptr;

  } 
  if (value < (*ptr)->data)
    return insertNodeHelper( &((*ptr)->leftPtr), value);
  return insertNodeHelper( &((*ptr)->rightPtr), value);
}

template<class NODETYPE>
TreeNode<NODETYPE>* Tree<NODETYPE>::findNode(const NODETYPE &value)
{
  return findNodeHelper(rootPtr, value);
}

template<class NODETYPE>
TreeNode<NODETYPE>* Tree<NODETYPE>::findNodeHelper(TreeNode<NODETYPE> *ptr,
				    const NODETYPE &value)
{
  if (ptr == 0)
	return 0;

  if (value == ptr->data)
    return ptr;

  if (value < ptr->data)
    return findNodeHelper(ptr->leftPtr, value);
  return findNodeHelper(ptr->rightPtr, value);
}

template<class NODETYPE>
void Tree<NODETYPE>::preOrderTraversal() const
{ preOrderHelper(rootPtr); }

template<class NODETYPE>
void Tree<NODETYPE>::preOrderHelper(TreeNode<NODETYPE> *ptr) const
{
  if (ptr != 0) {
    ptr->data.print();
    preOrderHelper(ptr->leftPtr);
    preOrderHelper(ptr->rightPtr);
  }
}

template<class NODETYPE>
int Tree<NODETYPE>::getcounter() { return counter; }

template<class NODETYPE>
void Tree<NODETYPE>::ConvertToArray(NODETYPE **ndArray, int n)
{
  if (counter != n) return;

  id = 0;
  convertToarrayHelper(rootPtr, ndArray);
}

template<class NODETYPE>
void Tree<NODETYPE>::convertToarrayHelper(TreeNode<NODETYPE> *ptr,
					  NODETYPE **ndARRAY)
{
  if (ptr != 0) {
    ndARRAY[id] = &(ptr->data);
    id ++;

    convertToarrayHelper(ptr->leftPtr, ndARRAY);
    convertToarrayHelper(ptr->rightPtr, ndARRAY);
  }
}

#endif