*二叉树的基本操作（递归实现）*

1. 二叉树的存储结构（二叉链表）

typedef char TElemType;
typedef char Status;
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild, *rchild;//左右孩子指针
} BiTNode, *BiTree;

2. 按先序序列建立二叉树

char c
;
int i=0;
(多组输入时，i=0初始化在while内)
Status CreateBiTree (BiTree &T)
{
ch = c[i++]; //读入一个字符
if (ch=='#') T=NULL; //返回上一级调用
else
{
T=(BiTNode *) malloc (sizeof(BiTNode));
if(!T)  exit(0);
T->data=ch;
CreateBiTree (T->lchild); //先调用后返回
CreateBiTree (T->rchild);
}
return 1;
}

3. 遍历二叉树

//（1）前序遍历
void preorder(BiTree &T)
{
if(T)
{
printf("%c", T->data);
preorder(T->lchild);
preorder(T->rchild);

}
}

//（2）中序遍历
void inorder(BiTree &T)
{
if(T)
{
inorder(T->lchild);
printf("%c", T->data);
inorder(T->rchild);
}
}

//（3）后序遍历
void postorder(BiTree &T)
{
if(T)
{
postorder(T->lchild);
postorder(T->rchild);
printf("%c", T->data);
}
}

4. 统计叶子结点个数

void CountLeaf(BiTree T, int &count)
{
if (T)
{
if ((!T->lchild)&&(!T->rchild))//叶子结点特征
count++;     // 对叶子结点计数
CountLeaf(T->lchild, count);
CountLeaf(T->rchild, count);//先序遍历
}
} //注意：调用本函数之前，count应该预设为0；

5. 求二叉树的深度(后序遍历)

int depth(BiTree T)
{
int ld, rd;
if(!T) return 0;
else
{
ld=depth(T->lchild);
rd=depth(T->rchild);
if(ld>rd)
return ld+1;
else
return rd+1;
}

}

6. 层序遍历（与队列结合）

void Traverse(BiTree T)
{
SqQueue Q;
BiTree p;
p=T;
InitQueue(Q); //队列初始化
if(p)
EnQueue(Q, p);//根节点入队
while(!QueueEmpty(Q))//循环直到队列Q为空
{
DeQueue(Q, p);//队首元素出队
printf("%c", p->data);//访问队首元素结点q的数据域
if(p->lchild)
EnQueue(Q, p->lchild);//若结点q存在左孩子，则将左孩子入队；
if(p->rchild)
EnQueue(Q, p->rchild);//若结点q存在右孩子，则将右孩子入队；
}

}

*****

已知前序和中序序列创建二叉树

BiTNode* BinaryTree(char* preorder, char* inorder, int length)//已知前序和中序
{
if(length == 0)//递归结束条件
{
return;
}
BiTNode* T = new BiTNode;
T->data = *preorder;//前序序列的第一个元素即为根节点
int rootIndex = 0;
for(; rootIndex < length; rootIndex++)//找到根节点在中序序列中的位置，用以划分左右子树
{
if(inorder[rootIndex] == *preorder)
break;
}
//Left
T->lchild = BinaryTree( preorder +1, inorder, rootIndex);//对左子树重复上述操作
//Right
T->rchild = BinaryTree(preorder + rootIndex + 1, inorder + rootIndex + 1, length - (rootIndex + 1));//对右子树重复上述操作
//输出位置（求后序序列）
return T;
}

void BinaryTree(BiTree& T, char pre[], char ino[],int ps, int is, int length)//ps：前序序列起始位置
//is：中序序列起始位置
{
if (length==0) T=NULL;
else
{
int k=0;
int n = strlen(ino);
for(k=0; k<n; k++)//找到根节点在中序序列中的位置，用以划分左右子树
{
if(ino[k]==pre[ps])//前序序列的第一个元素即为根节点
break;
}
T= new BiTNode;
if (!T)  exit(0);
T->data = pre[ps];
if (k==is)  T->lchild = NULL;//若前序中根结点在中序左子树序列的起始位置，则此结点左子树为空
else  BinaryTree(T->lchild, pre[], ino[], ps+1, is, k-is);
if (k==is+length-1) T->rchild = NULL;
else  BinaryTree(T->rchild, pre[], ino[], ps+1+(k-is), k+1, length-(k-is)-1);

}
}

已知中序和后序序列创建二叉树

BiTNode* BinaryTree(char* inorder, char* aftorder, int length)//已知中序和后序序列
{
if(length == 0)//递归结束条件
{
return;
}
BiTNode* T = new BiTNode;
T->data = *(aftorder+length-1);//后序序列中最后一个结点即为根节点
//输出位置（求前序序列）
int rootIndex = 0;
for(;rootIndex < length; rootIndex++)//寻找根节点在中序序列中的位置用以划分左右子树
{
if(inorder[rootIndex] ==  *(aftorder+length-1))
break;
}
T->lchild = BinaryTree(inorder, aftorder , rootIndex);//对左子树重复上述操作
T->rchild = BinaryTree(inorder + rootIndex + 1, aftorder + rootIndex , length - (rootIndex + 1));//对右子树重复上述操作

return T;
}
void BinaryTree(bitree& t, char aft[], char ino[],int ps, int is, int length)//ps：前序序列起始位置
//is：中序序列起始位置
{
if (length==0) t=NULL;
else
{
int k=0;
int n = strlen(ino);
for(k=0; k<n; k++)//找到根节点在中序序列中的位置，用以划分左右子树
{
if(ino[k]==aft[ps+length-1])//后序序列的最后一个元素即为根节点
break;
}
t= new bitnode;
if (!t)  exit(0);
t->data = aft[ps+length-1];
if (k==is)  t->lchild = NULL;//若仅有一个元素，则此结点左子树为空
else  BinaryTree(t->lchild, aft, ino, ps, is, k-is);
if (k==is+length-1)  t->rchild = NULL; //若仅有一个元素，则此结点右子树为空
else  BinaryTree(t->rchild, aft, ino, ps+(k-is), k+1, length-(k-is)-1);

}

}