二叉树的基本操作（递归和非递归）

递归：

#include
#include
#include 
using namespace std;
#define MAX 20
int g_num;
typedef struct BTNode{       /*节点结构声明*/
	char data ;               /*节点数据*/
	struct BTNode *lchild;
	struct BTNode *rchild ;  /*指针*/
}BTNode,*BiTree;

void createBiTree(BiTree *t){ /* 先序遍历创建二叉树*/
	char s;
	BiTree q;
	s=getchar();
	if(s=='#'){*t=NULL; return;}
	q=(BiTree)malloc(sizeof(struct BTNode));
	if(q==NULL){printf("Memory alloc failure!"); exit(0);}
	q->data=s;
	*t=q;
	createBiTree(&q->lchild); /*递归建立左子树*/
	createBiTree(&q->rchild); /*递归建立右子树*/
}

void PreOrder(BiTree p){  /* 先序遍历二叉树*/
    if ( p!= NULL ) {
       	printf("%c", p->data);
       	PreOrder( p->lchild ) ;
       	PreOrder( p->rchild) ;
    }
}
void InOrder(BiTree p){  /* 中序遍历二叉树*/
    if( p!= NULL ) {
 	 InOrder( p->lchild ) ;
   	 printf("%c", p->data);
   	 InOrder( p->rchild) ;
    }
}
void PostOrder(BiTree p){  /* 后序遍历二叉树*/
   if ( p!= NULL ) {
    	PostOrder( p->lchild ) ;
       	PostOrder( p->rchild) ;
       	printf("%c", p->data);
    }
}

void Preorder_n(BiTree p){ /*先序遍历的非递归算法*/
    BiTree stack[MAX],q;
    int top=0,i;
    for(i=0;idata);
        if(q->rchild!=NULL) stack[top++]=q->rchild;
        if(q->lchild!=NULL) q=q->lchild;
        else
            if(top>0) q=stack[--top];
            else q=NULL;
    }
}

void release(BiTree t){ /*释放二叉树空间*/
  	if(t!=NULL){
    	release(t->lchild);
    	release(t->rchild);
    	free(t);
  	}
}
//deepth
int Depth(BiTree p)
{
    int m,n;
    if(p==NULL)
    {
        return 0;
    }
    else
    {
         m = Depth(p->lchild);
         n = Depth(p->rchild);
        return (m>n) ? m+1 : n+1;
     }
}
//sum of node
int Nodecount(BiTree p)
{
    if(p==NULL)
    {
        return 0;
    }
    else
        return Nodecount(p->lchild) + Nodecount(p->rchild) + 1;
}
//leaf
void countleaf(BiTree p)
{
    if(p){
        if(p->lchild==NULL&&p->rchild==NULL)
        {
            g_num++;
        }
        else{
            countleaf(p->lchild);
            countleaf(p->rchild);
        }
    }
}
BTNode* copyBiTree(BiTree T)
{
    BiTree NLT = NULL;
    BiTree NRT = NULL;
    BiTree newNode = new BTNode;
    if(T->lchild)
    {
        NLT = copyBiTree(T->lchild);
    }
    else
    {
        NLT = NULL;
    }
    if(T->rchild)
    {
        NRT = copyBiTree(T->rchild);
    }
    else
    {
        NRT = NULL;
    }
    if(newNode == NULL)
    {
        return 0;
    }
    newNode->lchild = NLT;
    newNode->rchild = NRT;
    newNode->data = T->data;
    return newNode;

}
int main(){
    BiTree t=NULL;
    printf("\nplease input data:(exit for #)");
    createBiTree(&t);
    BiTree newT = NULL;
    newT = copyBiTree(t);
    g_num = 0;
    cout<<"PreOrder the tree is:";
    PreOrder(t);
    cout<

非递归：

#include 
#include 
#include 
#include 
#include 
using namespace std;

typedef struct BiTreeNode
{
    struct BiTreeNode * lchild;
    struct BiTreeNode * rchild;
    char data;
}BiTreeNode,*BiTree;

void createBiTree(BiTree *t){ /* 先序遍历创建二叉树*/
	char s;
	BiTree q;
	s=getchar();
	if(s=='#'){*t=NULL; return;}
	q=(BiTree)malloc(sizeof(struct BiTreeNode));
	if(q==NULL){printf("Memory alloc failure!"); exit(0);}
	q->data=s;
	*t=q;
	createBiTree(&q->lchild); /*递归建立左子树*/
	createBiTree(&q->rchild); /*递归建立右子树*/
}

BiTreeNode *GoFarLeft(BiTreeNode *T,stack &s)
{
    if(T==NULL)
    {
        return NULL;
    }
    while(T->lchild)
    {
        s.push(T);
        T = T->lchild;
    }
    return T;
}

void InOrder(BiTree T)
{
    stack s;
    //step 1：一直往左走，找到中序遍历的起点
    BiTree t = GoFarLeft(T,s);
    while(t)
    {
        cout<data<<" ";
        //if lchild is not NULL,redo step 1
        if(t->rchild!=NULL)
        {
            t = GoFarLeft(t->rchild,s);
        }
        //visit the stack top element
        else if(!s.empty())
        {
            t = s.top();
            s.pop();
        }
        //if rchild is null&&stack is empty
        else
        {
            t = NULL;
        }
    }
}

int main()
{
    BiTree T;
    cout<<"input(end#)"<

注：非递归用到了c++栈容器，如果没学到的话可以自己编写栈程序也是一样的