用图形的方式来表现二叉树的结构,非常直观,也容易理解。但是,对于计算机来说,只能处理线性序列,因此需要通过遍历将树中的结点变成某种意义的线性序列。二叉树的遍历是指按照一定次序访问二叉树中的所有节点,且每个节点仅被访问一次的过程。是最基本的运算,是其他运算的基础。
二叉树的遍历方式:先序遍历,中序遍历,后序遍历和层次遍历。
可以通过递归和迭代来实现二叉树各种次序的遍历,
迭代有两方法:
(1) 用栈来存储结点信息;
(2) 增加指向双亲结点的双亲指针;
先序遍历:
递归算法:
void PreOrderTraverse_Recursion(BinTree T)
{
if (T)
{
// 访问根结点
Visit(T);
// 遍历左子树
PreOrderTraverse_Recursion(T->lChild);
// 遍历右子树
PreOrderTraverse_Recursion(T->rChild);
}
// 空树返回
return ;
}
非递归算法:
栈实现Version_1:
void PreOrderTraverse_Iteration1(BinTree T) // 栈实现
{// 结点入栈时访问
int top = -1; // 栈顶
BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈
BinTNode *p = T; // 当前指针指向根结点
// 当前指针为空且栈为空时,遍历结束
while (p!=NULL || top!=-1) // !(p==NULL && top==-1)
{
while (p != NULL)
{
// 访问结点
Visit(p);
// 结点指针入栈
stack[++top] = p;
// 将左子树的根结点置为当前结点
p = p->lChild;
}
if (top != -1)
{
// 弹出栈顶,并将栈顶的右子树置为当前结点
p = stack[top--]->rChild;
}
}
// 遍历结束,返回
return ;
}
栈实现Version_2:
void PreOrderTraverse_Iteration2(BinTree T) // 栈实现
{
if (T)
{
int top = -1; // 栈顶
BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈
stack[++top] = T; // 根结点入栈
while (top != -1)
{
// 弹出栈顶
BinTNode *p = stack[top--];
// 访问结点
Visit(p);
if (p->rChild)
{
// 右子树根结点入栈
stack[++top] = p->rChild;
}
if (p->lChild)
{
// 左子树根结点入栈
stack[++top] = p->lChild;
}
}
}
return ;
}
双亲指针实现Version_1:
void PreOrderTraverse_Iteration3(BinTree T) // 双亲指针实现
{
BinTNode *p = T; // 当前结点指针
BinTNode *q = NULL; // 当前结点的双亲结点指针
while (p || q)
{
// 从根结点开始,沿左子树遍历,直至左子树为空
while (p)
{
// 访问结点
Visit(p);
q = p;
p = p->lChild;
}
// 结点q为叶结点,则沿左子树回溯
while (q && q->rChild==NULL && q->parent && q==q->parent->lChild)
{
q = q->parent;
}
if (q)
{
if (q->rChild) // 存在右子树,则遍历右子树
{
p = q->rChild;
}
else // 无右子树
{
// 沿右子树回溯
while (q && q->parent && q==q->parent->rChild)
{
q = q->parent;
}
q = q->parent;
if (q)
{
p = q->rChild;
}
}
}
}
return ;
}
双亲指针实现Version_2:
void PreOrderTraverse_Iteration4(BinTree T) // 增加访问标志
{
BinTNode *p = T;
while (p)
{
if (p->bVisited == false)
{
Visit(p);
p->bVisited = true;
}
// 左子树
if (p->lChild && p->lChild->bVisited==false)
{
p = p->lChild;
}
// 右子树
else if (p->rChild && p->rChild->bVisited==false)
{
p = p->rChild;
}
// 回溯到上一层
else
{
p = p->parent;
}
}
return ;
}
采用双亲指针实现关键在于回溯。为了回溯增加指向父亲节点的指针,以及是否已经访问的标志位,增加的空间复杂度为O(n)。时间方面,每个节点被访问一次。但是,当由叶子节点跳到下一个要访问的节点时,需要先回溯至父亲节点,再判断是否存在没有被访问过的右子树,如果没有,则继续回溯,直至找到一颗没有被访问过的右子树,这个过程需要很多的时间。每个叶子节点的回溯需要O(h)时间复杂度,叶子节点最多为(2^(h-1)),因此回溯花费的上限为O(h*(2^(h-1))。这个上限应该可以缩小。双亲指针实现唯一的好处是不需要额外的数据结构-栈。
中序遍历:
递归算法:
void InOrderTraverse_Recursion(BinTree T)
{
if (T)
{
// 遍历左子树
InOrderTraverse_Recursion(T->lChild);
// 访问根结点
Visit(T);
// 遍历右子树
InOrderTraverse_Recursion(T->rChild);
}
// 空树返回
return ;
}
非递归算法:
栈实现:
void InOrderTraverse_Iteration1(BinTree T) // 栈实现
{// 结点出栈时访问
int top = -1; // 栈顶
BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈
BinTNode *p = T; // 当前指针指向根结点
// 当前指针为空且栈为空时,遍历结束
while (p!=NULL || top!=-1) // !(p==NULL && top==-1)
{
while (p != NULL)
{
// 结点指针进栈
stack[++top] = p;
// 将左子树的根结点置为当前结点
p = p->lChild;
}
if (top != -1)
{
// 弹出栈顶
p = stack[top--];
// 访问结点
Visit(p);
// 将右子树的根结点置为当前结点
p = p->rChild;
}
}
// 遍历结束,返回
return ;
}
双亲指针实现:
void InOrderTraverse_Iteration2(BinTree T) // 双亲指针实现
{
BinTNode *p = T;
while (p!=NULL)
{
// 沿左子树向下搜索当前子树尚未访问的最左结点
while (p->lChild!=NULL && p->lChild->bVisited==false)
{
p = p->lChild;
}
// 访问未访问的最左结点
if (p->bVisited == false)
{
Visit(p);
p->bVisited = true;
}
if (p->rChild!=NULL && p->rChild->bVisited==false)
{
// 遍历当前结点的右子树
p = p->rChild;
}
else
{
// 回溯至双亲结点
p = p->parent;
}
}
return ;
}
后序遍历:
递归算法:
void PostOrderTraverse_Recursion(BinTree T)
{
if (T)
{
// 遍历左子树
PostOrderTraverse_Recursion(T->lChild);
// 遍历右子树
PostOrderTraverse_Recursion(T->rChild);
// 访问根结点
Visit(T);
}
// 空树返回
return ;
}
非递归算法:
栈实现Version_1:
void PostOrderTraverse_Iteration1(BinTree T) // 栈实现
{ // 结点两次出现在栈顶方可访问
int top = -1; // 栈顶
BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈
bool isFirst[MAX_SIZE]; // 标识结点出现在栈顶的次数(也可以对结点重新封装,定义在结点的结构体中)
BinTNode *p = T; // 当前结点指针指向根结点
while (p!=NULL || top!=-1)
{
while (p!=NULL)
{
// 结点入栈
++top;
stack[top] = p;
// 更新标识
isFirst[top] = true;
// 将左子树的根结点置为当前结点
p = p->lChild;
}
if (top != -1)
{
// 获取栈顶
p = stack[top];
// 判断栈顶结点的标识
if (isFirst[top] == true)
{
isFirst[top] = false;
// 遍历右子树
p = p->rChild;
}
else
{
// 弹出栈顶
p = stack[top--];
// 访问结点
Visit(p);
// 指针p置空,以便取出下一个结点
p = NULL;
}
}
}
return ;
}
栈实现Version_2:
void PostOrderTraverse_Iteration2(BinTree T) // 栈实现
{
int top = -1; // 栈顶
BinTNode *stack[MAX_SIZE]; // 保存结点指针信息的栈
BinTNode *p = T; // 根结点置为当前结点
BinTNode *pre = NULL; // 前一次访问的结点
// 根结点入栈
if (p)
{
stack[++top] = p;
}
while (top!=-1)
{
p = stack[top];
// 访问结点:(1)左右子树均为空;(2)前一个访问结点尾该结点的左孩子或右孩子
if ((p->lChild==NULL && p->rChild==NULL) ||
(pre!=NULL && (pre==p->lChild || pre==p->rChild)))
{
Visit(p);
top--;
pre = p;
}
else
{
// 右子树
if (p->rChild != NULL)
{
stack[++top] = p->rChild;
}
// 左子树
if (p->lChild != NULL)
{
stack[++top] = p->lChild;
}
}
}
return ;
}
层次遍历:
void LevelTraverse(BinTree T)
{
int front, rear; // 队头、队尾指针
BinTNode *queue[MAX_SIZE]; // 保存结点指针信息的队列
front = rear = 0;
BinTNode *p = T;
// 根结点入队
if (p)
{
queue[rear] = p;
rear = (rear+1)%MAX_SIZE;
}
while (rear != front)
{
// 队头出队
p = queue[front];
front = (front+1)%MAX_SIZE;
// 访问结点
Visit(p);
// 左子树
if (p->lChild)
{
queue[rear] = p->lChild;
rear = (rear+1)%MAX_SIZE;
}
// 右子树
if (p->rChild)
{
queue[rear] = p->rChild;
rear = (rear+1)%MAX_SIZE;
}
}
return ;
}
小结:
用栈来实现比增加指向父节点指针回溯更方便;
采用第一个思想,就是跟踪指针移动 用栈保存中间结果的实现方式,先序与中序难度一致,后序很困难。先序与中序只需要修改一下访问的位置即可。
采用第二个思想,直接用栈来模拟递归,先序非常简单;而中序与后序难度一致。先序简单是因为节点可以直接访问,访问完毕后无需记录。而中序与后序时,节点在弹栈后还不能立即访问,还需要等其他节点访问完毕后才能访问,因此节点需要设置标志位来判定,因此需要额外的O(n)空间。