二叉树的创建、遍历以及部分算法

首先创建一棵二叉树。

遍历（非层次）的递归算法代码比较简洁，非递归算法则需要使用栈。

层次遍历则需要使用队列。

需要注意栈与队列的存储结构需要使用BiTNode*类型（二叉树的结点类型）。因为遍历时需要把结点的指针出入栈与队列。

代码如下：

#include <iostream>
using namespace std;
//二叉树的二叉链表存储表示
typedef struct BiTNode{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//顺序栈的存储表示
#define MAXSIZE 100
typedef struct
{
    BiTNode *base;
    BiTNode *top;
}SqStack;

//栈的初始化
void InitStack(SqStack &S)
{

    S.base=new BiTNode[MAXSIZE];
    S.top=S.base;
}

//入栈
int Push(SqStack &S,BiTNode *p)
{
    //插入元素为e的新元素
    if(S.top-S.base==MAXSIZE)return 0;
    *S.top++=*p;
    return 1;
}

//出栈
int Pop(SqStack &S,BiTNode *q)
{
    //删除S的栈顶元素，用e返回其值
    if(S.top==S.base)return 1;
    *q=*--S.top;
    return 0;
}
//判栈空
int StackEmpty(SqStack &S)//判断栈是否为空
{
    if(S.base==S.top)
    return 1;
    else
    return 0;
}

//队列的存储结构
#define MAXQSIZE 100
typedef struct
{
    BiTNode *base;
    int front;
    int rear;
}SqQueue;

//队列的初始化
void InitQueue(SqQueue &Q)
{
    //构造一个空队列Q
    Q.base=new BiTNode[MAXQSIZE];
    Q.front=Q.rear=0;
}

//判队空
int QueueEmpty(SqQueue Q)
{
    //返回Q的元素个数，即队列长度
    if((Q.rear-Q.front+MAXQSIZE)%MAXQSIZE)return 0;
    else return 1;
}

//入队
void EnQueue(SqQueue &Q,BiTNode *p)
{
    //插入元素e为Q的新的队尾元素
    if((Q.rear+1)%MAXQSIZE==Q.front)
    cout<<"队已满，插入失败！"<<endl;
    Q.base[Q.rear]=*p;
    Q.rear=(Q.rear+1)%MAXQSIZE;
}

//出队
int DeQueue(SqQueue &Q,BiTNode *q)
{
    //删除Q的队尾元素，用e返回其值
    if(Q.front==Q.rear) return 0;
    *q=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXQSIZE;
    return 1;
}
//层次遍历
void InOrderTraverse_c(BiTree T)
{
    SqQueue Q;
    InitQueue(Q);
    BiTNode *p;BiTNode *q;
    p=T;q=new BiTNode;
    while(p||!QueueEmpty(Q))
    {
        if(p)
        {
            EnQueue(Q,p);
            p=p->lchild;

        }
        else
        {
            DeQueue(Q,q);
            cout<<q->data;
            p=q->rchild;
        }
    }
}

//先序遍历的顺序建立二叉链表
void CreateBiTree_x(BiTree &T)
{
	char ch;
	cin>>ch;
	if(ch=='#')T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		CreateBiTree_x(T->lchild);
		CreateBiTree_x(T->rchild);
	}
}

//先序遍历的递归算法
void InOrderTraverse_x(BiTree T)
{
	if(T)
	{
		cout<<T->data;
		InOrderTraverse_x(T->lchild);
		InOrderTraverse_x(T->rchild);
	}
}
//中序遍历的递归算法
void InOrderTraverse_z(BiTree T)
{
	if(T)
	{
		InOrderTraverse_z(T->lchild);
		cout<<T->data;
		InOrderTraverse_z(T->rchild);
	}
}
//双序遍历
void InOrderTraverse_d(BiTree T)
{
	if(T)
	{
	    cout<<T->data;
		InOrderTraverse_d(T->lchild);
		cout<<T->data;
		InOrderTraverse_d(T->rchild);
	}
}

//先序遍历的非递归算法
void InOrderTraverse_x_f(BiTree T)
{
    SqStack S;
    InitStack(S);
    BiTNode *p;BiTNode *q;
    p=T;q=new BiTNode;
    while(p||!StackEmpty(S))
    {
        if(p)
        {
            Push(S,p);
            cout<<p->data;
            p=p->lchild;

        }
        else
        {
            Pop(S,q);
            p=q->rchild;
        }
    }
}
//中序遍历的非递归算法
void InOrderTraverse_z_f(BiTree T)
{
    SqStack S;
    InitStack(S);
    BiTNode *p;BiTNode *q;
    p=T;q=new BiTNode;
    while(p||!StackEmpty(S))
    {
        if(p)
        {
            Push(S,p);
            p=p->lchild;
        }
        else
        {
            Pop(S,q);
            cout<<q->data;
            p=q->rchild;
        }
    }
}
//计算二叉树的深度
int Depth(BiTree T)
{
    int m,n;
    if(T==NULL) return 0;
    else
    {
        m=Depth(T->lchild);
        n=Depth(T->rchild);
        if(m>n)return (m+1);
        else return(n+1);
    }

}
//统计二叉树结点的个数
int NodeCount(BiTree T)
{
    if(T==NULL)return 0;
    else return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}
//统计二叉树的叶结点个数
int LeafCount(BiTree T)
{
	if(T==NULL)
		return 0; //如果是空树，则叶子结点个数为0
	else if(T->lchild==NULL&&T->rchild==NULL)
		return 1; //判断结点是否是叶子结点（左孩子右孩子都为空），若是则返回1
	else
		return LeafCount(T->lchild)+LeafCount(T->rchild);
}
//交换二叉树每个结点的左孩子和右孩子
void ChangeLR(BiTree &T)
{
	BiTNode *temp;
	if(T->lchild!=NULL||T->rchild!=NULL)
	{
		temp=T->lchild;
		T->lchild=T->rchild;
		T->rchild=temp;
	}//交换左右孩子
	if(T->lchild)ChangeLR(T->lchild);
	if(T->rchild)ChangeLR(T->rchild);
}

int main()
{
	BiTree T;int n;
    cout<<"首先（根据先序遍历的顺序）创建一棵二叉树："<<endl;
	cout<<"请输入二叉树中的结点：（由字母组成，#为触底标志）:"<<endl;
	CreateBiTree_x(T);

	cout<<"先序遍历（递归）的结果为:"<<endl;
	InOrderTraverse_x(T);
	cout<<endl;

	cout<<"先序遍历（非递归）的结果为:"<<endl;
	InOrderTraverse_x_f(T);
	cout<<endl;

	cout<<"中序遍历（递归）的结果为:"<<endl;
	InOrderTraverse_z(T);
	cout<<endl;

	cout<<"中序遍历（非递归）的结果为:"<<endl;
	InOrderTraverse_z_f(T);
	cout<<endl;

    cout<<"层次遍历的结果为:"<<endl;
	InOrderTraverse_c(T);
	cout<<endl;

	cout<<"双序遍历的结果为:"<<endl;
	InOrderTraverse_d(T);
	cout<<endl;

	n=Depth(T);
	cout<<"二叉树的深度为："<<n<<endl;

	n=NodeCount(T);
	cout<<"二叉树的节点个数为："<<n<<endl;

	n=LeafCount(T);
	cout<<"其中叶子节点个数为："<<n<<endl;

	ChangeLR(T);

	cout<<"交换左右孩子后先序遍历的结果为:"<<endl;
	InOrderTraverse_x(T);
	cout<<endl;

	cout<<"交换左右孩子后中序遍历的结果为:"<<endl;
	InOrderTraverse_z(T);
    cout<<endl;

	return 0;

}