二叉树的基本操作（总结）

二叉树的基本操作

二叉树的定义决定了其大多数操作都可以由递归去实现

本文通过递归和非递归两种方式实现二叉树的基本操作（加深对原理的理解）

1.二叉树的声明

typedef char ElementType;
typedef struct TreeNode* BinTree;
struct TreeNode{
ElementType Data;
struct TreeNode* Left;
struct TreeNode* Right;
};

2.遍历

（1）递归实现

>1  先序遍历

按照“根节点-左儿子-右儿子”的顺序访问

void PreorderTraversal(BinTree BT) {
if (!BT) return;    //空树，直接返回
visit(BT->Data);
PreorderTraversal(BT->Left);    //递归遍历左子树
PreorderTraversal(BT->Right);   //递归遍历右子树
}

>2  中序遍历

按照“左儿子-根节点-右儿子”的顺序访问

void InorderTraversal(BinTree BT){
if(!BT) return ;
InorderTraversal(BT->Left);
visit(BT->Data);
InorderTraversal(BT->Right);
}

 >3  后序遍历

按照“左儿子-右儿子-根节点”的顺序访问

void PostorderTraversal(BinTree BT){
if(!BT) return ;
InorderTraversal(BT->Left);
InorderTraversal(BT->Right);
visit(BT->Data);
}

（2）非递归实现（二叉树的非递归实现借助栈来实现）

属于哪种遍历取决于根节点第几次遇到时访问

>1  先序遍历（首次遇到时访问）

//C语言实现
int MaxSize = 1000;
void PreorderTraversalRecur(BinTree BT) {
TreeNode* St[MaxSize], *p;	//创建一个栈
int top = -1;	//top的下一个位置指向栈顶
if (!BT) {
St[++top] = BT;	//根节点入栈
while (top > -1) {
p = St[top];
top--;
printf("%c ", p->Data);	//先序遍历，第一次遇到（入栈）时就访问
//左右子树压栈
if (!p->Left) 	St[++top] = p->Left;
if (!p->Right) 	St[++top] = p->Right;
}
}
}

//C++实现
void PreOrderTraversal(BinTree BT) {
if (!BT)   return;
stack<BinTree> s;
BinTree temp;
s.push(BT);
while (!s.empty()) {
temp = s.top();
printf("%c ", temp->Data);
s.pop();
if (temp->Left)		s.push(temp->Left);
if (temp->Right)	s.push(temp->Right);
}
}

>2  中序遍历

void InorderTraversal(BinTree BT) {
TreeNode *St[MaxSize], *node;
int top = -1;
if (!BT) {
node = BT;
while (top > -1 || node != NULL) {
//先把所有的左子树压栈
while (node != NULL) {
St[++top] = node;
node = node->Left;
}
//回溯，访问最后入栈的结点的右子树
if (top > -1) {
node = St[top--];	//取除栈顶元素，并且top--
printf("%c ", node->Data);	//此时第二次遇到根节点，访问
node = node->Right;
}
}
}
}

void InOrderTravel(BinTree BT) {
if (!BT)   return;
stack<BinTree> s;
BinTree node = BT;
while (!node || !s.empty()) {
while (!s.empty() || node) {
//一直遍历到左子树最下边，边遍历边保存根节点到栈中
while (node) {
s.push(node);
node = node->Left;
}
//当p为空时，说明已经到达左子树最下边，这时需要出栈了
if (!s.empty()) {
node = s.top();
s.pop();
printf("%c ", node->Data);
//进入右子树，开始新的一轮左子树遍历(这是递归的自我实现)
node = node->Right;
}
}
/*
//另解
while (!s.empty() || node) {
if (node) {
s.push(node);
node = node->Left;
}
else {
node = s.top();
s.pop();
printf("%c ", node->Data);
node = node->Right;
}
}
*/
}
}

>3  后序遍历

//C++实现
void PostorderTraversalRecursion(BinTree BT) {
if (!BT)	return;
stack<BinTree> s;
//pCur:当前访问节点，pLast:上次访问节点
BinTree pCur, pLast;
pCur = BT;
pLast = NULL;
//把左子树结点全部压栈
while (pCur) {
s.push(pCur);
pCur = pCur->Left;
}
//已经遍历到左子树底端
while (!s.empty()) {
pCur = s.top();
s.pop();

if (pCur->Left == pLast) {	//若左子树刚被访问过，则需先进入右子树(根节点需再次入栈)
//根节点再次入栈
s.push(pCur);
//进入右子树，且可肯定右子树一定不为空
pCur = pCur->Right;
while (pCur) {
s.push(pCur);
pCur = pCur->Right;
}
}
//一个根节点被访问的前提是：无右子树或右子树已被访问过
else if (pCur->Right == NULL || pCur->Right == pLast) {
printf("%c ", pCur->Data);
//修改最近被访问的节点
pLast = pCur;
}
}
}

参考：http://blog.csdn.net/zhangxiangdavaid/article/details/37115355

层序遍历（利用队列实现）

>1   C语言实现队列

void LevelorderTraversal(BinTree BT) {
BinTree q[1000];
BinTree temp;
int head = 0, tail = 0;
if (!BT) return;
else {
q[tail++] = BT;
while (tail != head) {
temp = q[head++];
printf(" %c", temp->Data);
if (temp->Left)     q[tail++] = temp->Left;
if (temp->Right)    q[tail++] = temp->Right;
}
}
}

2>   C++（queue）实现

void LevelorderTraversal(BinTree BT) {
queue <BinTree> q;
BinTree temp;
if (!BT) return;
else {
q.push(BT);	//根节点入队
while (!q.empty()) {
temp = q.front();
q.pop();	//队首元素出队，并访问
cout << temp->Data << ' ';
if (temp->Left)    q.push(temp->Left);	//左儿子入队
if (temp->Right)   q.push(temp->Right);	//右儿子入队
}
}
}

3.其他操作

（1）求树的高度

int GetHeight(BinTree BT) {
/*
if (BT == NULL)
return 0;
else return 1 +(GetHeight(BT->Left) > GetHeight(BT->Right) ? GetHeight(BT->Left): GetHeight(BT->Right));
*/

int h = 0;
if (BT == NULL) {
return 0;
}
int lh = GetHeight(BT->Left) + 1;
int rh = GetHeight(BT->Right) + 1;

h = lh > rh ? lh : rh;
return h;
}

（2）求二叉树结点的个数

int Nodenum(BinTree BT)  {
if(!BT)  return 0;
else    return 1+Nodenum(BT->Left)+Nodenum(BT->Right);
}

（3）求叶子结点的个数

int LeavesCount(BiTree BT)  {
if(!BT == NULL)   return 0;   //BT为空树，返回0

int cnt = 0;
if(!(BT->LChild || BT->RChild))  ++cnt;   //BT为叶子结点，加1
else {
//递归求左子树上的叶子结点，并累加
cnt += LeavesCount(BT->LChild);
//递归求右子树上的叶子结点，并累加
cnt += LeavesCount(BT->RChild);
}
return cnt;
}

本人才疏学浅，如有错误，欢迎大家指正