Maxwell-TD-Scattering/MaxwellTD_GPU_Port/utils/tree.h

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


template<class NODETYPE>
class Tree {
public:
  Tree();
  void insertNode(const NODETYPE &);
  void preOrderTraversal() const;
  TreeNode<NODETYPE> *findNode(const NODETYPE &);

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

  // get counter
  int getcounter();

private:
  TreeNode<NODETYPE> *rootPtr;
  TreeNode<NODETYPE> *tmpPtr;
  int counter;

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

template<class NODETYPE>
Tree<NODETYPE>::Tree() { rootPtr = 0; counter = 0; }

template<class NODETYPE>
void Tree<NODETYPE>::insertNode(const NODETYPE &value)
{ 
  insertNodeHelper(&rootPtr, value); 
}

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

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

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

  return tmpPtr;
}

template<class NODETYPE>
void Tree<NODETYPE>::findNodeHelper(TreeNode<NODETYPE> *ptr,
				    const NODETYPE &value)
{
  if (ptr == 0) return;
  
  if (value == ptr->data) {
    tmpPtr = ptr;
    
    return;
  }
  else {
    if (value < ptr->data) findNodeHelper(ptr->leftPtr, value);
    else
      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>
void Tree<NODETYPE>::setcounter(int cnt) { counter = cnt; }

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

template<class NODETYPE>
void Tree<NODETYPE>::numberData(int bType)
{
  numberDataHelper(rootPtr, bType);
}

template<class NODETYPE>
void Tree<NODETYPE>::numberDataHelper(TreeNode<NODETYPE> *ptr, int bType)
{
  if (ptr == 0) return;

  if ((ptr->data).getbType() == bType) {
    if ((ptr->data).getcnt() == -1) {
      (ptr->data).setcnt(counter);
      
      counter ++;
    }
  }

  numberDataHelper(ptr->leftPtr, bType);
  numberDataHelper(ptr->rightPtr, bType);
}

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

  convertToarrayHelper(rootPtr, ndArray);
}

template<class NODETYPE>
void Tree<NODETYPE>::convertToarrayHelper(TreeNode<NODETYPE> *ptr,
					  NODETYPE **ndARRAY)
{
  int nn;

  if (ptr == 0) return;
  if ((ptr->data).getcnt() >= 0) {
    nn = (ptr->data).getcnt();
    ndARRAY[nn] = &(ptr->data);
  }

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

#endif