//-----------------------------------------------------------------------------
#include <assert.h>
#include <iostream.h>   //----For NULL
#include "narytreeclass.h"
//-----------------------------------------------------------------------------
//----Public parts of treenode
//-----------------------------------------------------------------------------
//----Default constructor
template <class NodeType, int Degree>
treenode<NodeType,Degree>::treenode(void) {

}
//-----------------------------------------------------------------------------
//----Initial value constructor
template <class NodeType, int Degree>
treenode<NodeType,Degree>::treenode(NodeType InitialValue,
treenode<NodeType,Degree> *ParentNode) {

int Index;

Data = InitialValue;
Parent = ParentNode;

//----No offspring of new node
for (Index = 0; Index < Degree; Index++)
    Offspring[Index] = NULL;
}
//-----------------------------------------------------------------------------
//----Return the data in the node
template <class NodeType, int Degree>
NodeType treenode<NodeType,Degree>::GetData(void) {

return(Data);
}
//-----------------------------------------------------------------------------
//----Return the parent
template <class NodeType, int Degree>
treenode<NodeType,Degree> *treenode<NodeType,Degree>::GetParent(void) {

return(Parent);
}
//-----------------------------------------------------------------------------
//----Return an offspring
template <class NodeType, int Degree>
treenode<NodeType,Degree> *treenode<NodeType,Degree>::GetOffspring(
int OffspringIndex) {

if (OffspringIndex < Degree)
    return(Offspring[OffspringIndex]);
else return(NULL);
}
//-----------------------------------------------------------------------------
//----Add an offspring if one is not there already
template <class NodeType, int Degree>
boolean treenode<NodeType,Degree>::AddOffspring(int OffspringIndex,
NodeType Value) {

if (OffspringIndex < Degree && !OffspringExists(OffspringIndex)) {
    Offspring[OffspringIndex] = new treenode<NodeType,Degree>(Value,this);
    return(TRUE);
    }
else return(FALSE);
}
//-----------------------------------------------------------------------------
//----Add a tree as an offspring
template <class NodeType, int Degree>
boolean treenode<NodeType,Degree>::AddOffspringTree(int OffspringIndex,
tree<NodeType,Degree> Subtree) {

tree<NodeType,Degree> CopyTree(Subtree);

if (OffspringIndex < Degree && !OffspringExists(OffspringIndex)) {
    Offspring[OffspringIndex] = CopyTree.Root;
    CopyTree.Root = NULL;
    }
else return(FALSE);
}
//-----------------------------------------------------------------------------
//----Check if a given offspring exists
template <class NodeType, int Degree>
boolean treenode<NodeType,Degree>::OffspringExists(int OffspringIndex) {

return(OffspringIndex < Degree && Offspring[OffspringIndex] != NULL);
}
//-----------------------------------------------------------------------------
//----Public parts of tree
//-----------------------------------------------------------------------------
//----Default constructor
template <class NodeType, int Degree>
tree<NodeType,Degree>::tree(void) {

Root = NULL;
}
//-----------------------------------------------------------------------------
//----Copy constructor
template <class NodeType, int Degree>
tree<NodeType,Degree>::tree(const tree &CopyThisTree) {

Root = Copy(CopyThisTree.Root,NULL);
}
//-----------------------------------------------------------------------------
//----Assignment operator
//template <class NodeType, int Degree>
//const tree<NodeType,Degree> &tree<NodeType,Degree>::operator=(
//const tree<NodeType,Degree> AssignThisTree) {
//
//Destruct(Root);
//Root = Copy(AssignThisTree.Root,NULL);
//return(*this);
//}
//-----------------------------------------------------------------------------
//----Workhorse for copy constructor
template <class NodeType, int Degree>
treenode<NodeType,Degree>* tree<NodeType,Degree>::Copy(
treenode<NodeType,Degree> *CopyThisNode,
treenode<NodeType,Degree> *TheParent) {

treenode<NodeType,Degree> *NewNode;
int Index;

if (CopyThisNode != NULL) {
    NewNode = new treenode<NodeType,Degree>(CopyThisNode->Data,CopyThisNode);
    NewNode->Parent = TheParent;
    for (Index = 0; Index < Degree; Index++)
        NewNode->Offspring[Index] = Copy(CopyThisNode->Offspring[Index],
NewNode);
    return(NewNode);
    }
else return(NULL);
}
//-----------------------------------------------------------------------------
//----Destructor
template <class NodeType, int Degree>
tree<NodeType,Degree>::~tree(void) {

Destruct(Root);
}
//-----------------------------------------------------------------------------
//----Workhorse for destructor
template <class NodeType, int Degree>
void tree<NodeType,Degree>::Destruct(treenode<NodeType,Degree> *Node) {

int Index;

if (Node != NULL) {
    for (Index = 0; Index < Degree; Index++)
        Destruct(Node->Offspring[Index]);
    delete Node;
    }
}
//-----------------------------------------------------------------------------
//----Test if empty
template <class NodeType, int Degree>
boolean tree<NodeType,Degree>::Empty(void) {

return(Root == NULL);
}
//-----------------------------------------------------------------------------
//----Add a root node if not already there
template <class NodeType, int Degree>
boolean tree<NodeType,Degree>::AddRoot(NodeType InitialValue) {

if (Empty()) {
    Root = new treenode<NodeType,Degree>(InitialValue,NULL);
    return(TRUE);
    }
else return(FALSE);
}
//-----------------------------------------------------------------------------
#include "preordertraversal.cpp"
//-----------------------------------------------------------------------------
//----Public parts of treeiterator
//-----------------------------------------------------------------------------
//----Initial value contructor
template <class NodeType, int Degree>
treeiterator<NodeType,Degree>::treeiterator(
tree<NodeType,Degree> &TreeToIterate) {

TheTree = &TreeToIterate;
CurrentNodePointer = NULL;
}
//-----------------------------------------------------------------------------
//----Check if pointing at a node
template <class NodeType, int Degree>
boolean treeiterator<NodeType,Degree>::NodeExists(void) {

return(CurrentNodePointer != NULL);
}
//-----------------------------------------------------------------------------
//----Check if parent exists
template <class NodeType, int Degree>
boolean treeiterator<NodeType,Degree>::ParentExists(void) {

assert(NodeExists());
return(CurrentNodePointer->Parent != NULL);
}
//-----------------------------------------------------------------------------
//----Check if offspring exists
template <class NodeType, int Degree>
boolean treeiterator<NodeType,Degree>::OffspringExists(int OffspringIndex) {

assert(NodeExists());
return(CurrentNodePointer->OffspringExists(OffspringIndex));
}
//-----------------------------------------------------------------------------
//----Point to the root
template <class NodeType, int Degree>
void treeiterator<NodeType,Degree>::GoRoot(void) {

CurrentNodePointer = TheTree->Root;
}
//-----------------------------------------------------------------------------
//----Point to parent if any
template <class NodeType, int Degree>
void treeiterator<NodeType,Degree>::GoUp(void) {

assert(NodeExists());
CurrentNodePointer = CurrentNodePointer->Parent;
}
//-----------------------------------------------------------------------------
//----Point to child of exists
template <class NodeType, int Degree>
void treeiterator<NodeType,Degree>::GoDown(int OffspringIndex) {

assert(NodeExists());
assert(OffspringIndex < Degree);
CurrentNodePointer = CurrentNodePointer->Offspring[OffspringIndex];
}
//-----------------------------------------------------------------------------
//----Return current data
template <class NodeType, int Degree>
NodeType treeiterator<NodeType,Degree>::CurrentData(void) {

assert(NodeExists());
return(CurrentNodePointer->Data);
}
//-----------------------------------------------------------------------------
//----Add an offpring here if possible
template <class NodeType, int Degree>
boolean treeiterator<NodeType,Degree>::AddOffspring(int OffspringIndex,
NodeType Value) {

return(CurrentNodePointer->AddOffspring(OffspringIndex,Value));
}
//-----------------------------------------------------------------------------
//----Add a tree as an offspring
template <class NodeType, int Degree>
boolean treeiterator<NodeType,Degree>::AddOffspringTree(int OffspringIndex,
tree<NodeType,Degree> Subtree) {

return(CurrentNodePointer->AddOffspringTree(OffspringIndex,Subtree));
}
//-----------------------------------------------------------------------------