C++ 二叉树的构建，先序/中序/后序的递归/非递归实现

//BinNode.h

#ifndef BINNODE_H
#define BINNODE_H

class BinNode
{
public:
BinNode():data(0),lchild(0),rchild(0){};
BinNode *lchild,*rchild;
char *data;
};

#endif

//BinTree.h

#ifndef BINTREE_H
#define BINTREE_H

#include "BinNode.h"
#include <stack>
using std::stack;

class BinTree
{
public:
BinTree(int num);
void InsertNode(char *);
void PreOrderTraverse(void(*fun)(BinNode&));//递归式实现先序遍历
void InOrderTraverse(void(*fun)(BinNode&));//递归式实现中序遍历
void PostOrderTraverse(void(*fun)(BinNode&));//递归式实现后序遍历

void PreOrder(void(*fun)(BinNode&));//非递归式实现先序遍历
void InOrder(void(*fun)(BinNode&));//非递归式实现中序遍历
void PostOrder(void(*fun)(BinNode&));//非递归式实现后序遍历
~BinTree(){delete HEAD;}
BinNode *HEAD;
int NumOfNodes;
private:
void PreOrderTraverse(void(*fun)(BinNode&),BinNode *);
void InOrderTraverse(void(*fun)(BinNode&),BinNode *);
void PostOrderTraverse(void(*fun)(BinNode&),BinNode *);
void LevelOrderTraverse(void(*fun)(BinNode&),BinNode *);
int MAX_NUM;
stack<BinNode> s;
};

#endif

//BinTree.cpp

#include <cstring>
#include "BinTree.h"

BinTree::BinTree(int num)
{
MAX_NUM = num;
NumOfNodes = 0;
HEAD = 0;
}

void BinTree::InsertNode(char *to_data)
{
BinNode *temp = HEAD,*pre;
while(temp)
{
if(strcmp(to_data,temp->data) == 0)return;
pre = temp;
if(strcmp(to_data,temp->data) > 0)
temp = temp->rchild;
else
temp = temp->lchild;
}
BinNode *to_node = new BinNode;
to_node->data = to_data;

if(0 == HEAD)
{
HEAD = to_node;
NumOfNodes ++;
}
else
{
if(strcmp(to_data,pre->data) > 0)pre->rchild = to_node;
else pre->lchild = to_node;
NumOfNodes ++;
}
}

void BinTree::DeleteNode(BinNode &to_delete)//尚未实现
{
BinNode *temp = HEAD;
while(temp)
{
if(strcmp(temp->data,to_delete.data) > 0)
temp = temp->lchild;
if(strcmp(temp->data,to_delete.data) < 0)
temp = temp->rchild;
if(strcmp(temp->data,to_delete.data) == 0)
break;
}

if(0 == temp)return;
}

void BinTree::PreOrderTraverse(void (*fun)(BinNode &),BinNode *top)
{
BinNode *temp = top;
if(temp)
{
fun(*temp);
PreOrderTraverse(fun,temp->lchild);
PreOrderTraverse(fun,temp->rchild);
}
}

void BinTree::PreOrderTraverse(void(*fun)(BinNode&))
{
PreOrderTraverse(fun,HEAD);
}

void BinTree::InOrderTraverse(void (*fun)(BinNode &), BinNode *top)
{
BinNode *temp = top;
if(temp)
{
InOrderTraverse(fun,temp->lchild);
fun(*temp);
InOrderTraverse(fun,temp->rchild);
}
}

void BinTree::InOrderTraverse(void(*fun)(BinNode&))
{
InOrderTraverse(fun,HEAD);
}

void BinTree::PostOrderTraverse(void (*fun)(BinNode &), BinNode *top)
{
BinNode *temp = top;
if(temp)
{
PostOrderTraverse(fun,temp->lchild);
PostOrderTraverse(fun,temp->rchild);
fun(*temp);
}
}

void BinTree::PostOrderTraverse(void(*fun)(BinNode&))
{
PostOrderTraverse(fun,HEAD);
}

void BinTree::PreOrder(void(*fun)(BinNode&))
{
BinNode *temp = HEAD;
while(temp || !(s.empty()))
{
if(temp)
{
s.push(*temp);
fun(*temp);
temp = temp->lchild;
}
else
{
temp = &(s.top());
s.pop();
temp = temp->rchild;
}
}
}

void BinTree::InOrder(void(*fun)(BinNode&))
{
BinNode *temp = HEAD;
while(temp || !(s.empty()))
{
if(temp)
{
s.push(*temp);
temp = temp->lchild;
}
else
{
temp = &(s.top());
fun(*temp);
s.pop();
temp = temp->rchild;
}
}
}

void BinTree::PostOrder(void(*fun)(BinNode&))
{
BinNode *temp = HEAD;
BinNode *pre;
while(temp || !s.empty())
{
if(temp)
{
s.push(*temp);
temp = temp->lchild;
}
else
{
temp = &(s.top());
if(temp->rchild && (temp->rchild->data != pre->data))
{
temp = temp->rchild;
s.push(*temp);
temp = temp->lchild;
}
else
{
temp = &(s.top());
fun(*temp);
s.pop();
pre = temp;
temp = 0;
}
}
}
}

//driver.cpp

#include <iostream>
#include <string>
using namespace std;

#include "BinNode.h"
#include "BinTree.h"

const int MAX_NUM = 100;

void myfun(BinNode& BN)
{
cout<<BN.data<<endl;
}

int main()
{
BinTree *BT = new BinTree(MAX_NUM);

BinNode node_to2;
node_to2.data = "Another test program.";
BT->InsertNode(node_to2.data);

BinNode node_to;
node_to.data = "This is a test program.";
BT->InsertNode(node_to.data);

BinNode node_to3;
node_to3.data = "Ahahahahahahahah";
BT->InsertNode(node_to3.data);

cout<<"----------------PreOrderTraverse-----------------"<<endl;
BT->PreOrderTraverse(myfun);
cout<<"----------------InOrderTraverse------------------"<<endl;
BT->InOrderTraverse(myfun);
cout<<"----------------PostOrderTraverse----------------"<<endl;
BT->PostOrderTraverse(myfun);
cout<<"---------------------InOrder---------------------"<<endl;
BT->InOrder(myfun);
cout<<"---------------------PreOrder--------------------"<<endl;
BT->PreOrder(myfun);
cout<<"---------------------PostOrder-------------------"<<endl;
BT->PostOrder(myfun);
//	cout<<BT->NumOfNodes<<endl;
return 0;
}