目录
数据结构-树与二叉树(第七章)的整理笔记，若有错误，欢迎指正。
二叉树的遍历(递归算法)
- 二叉树的遍历是指按照一定的次序访问二叉树中的所有结点，并且每个结点仅被访问一次的过程。它是二叉树最基本的运算，是二叉树中所有其他运算实现的基础。
- 一棵二叉树由3个部分(即根结点、左子树和右子树)构成，可以从任何部分开始遍历，所以有3!(即6)种遍历方法。
- 若规定子树的遍历总是先左后右(先右后左与之对称)，则对于非空二叉树，可得到以下3种递归的遍历方法：即先序遍历、中序遍历和后序遍历。另外还有一种常见的层次遍历方法。
先序遍历
- 首先访问根节点，然后遍历左子树，最后遍历右子树；并且在遍历左子树和右子树时，仍然先访问根节点，然后遍历左子树，最后遍历右子树。
代码实现
void PreOrder(BTNode* b) //先序遍历
{
if (b != NULL)
{
printf("%d ", b->data); //访问根节点
PreOrder(b->lchild); //先序遍历左子树
PreOrder(b->rchild); //先序遍历右子树
}
}
程序分析
- 时间复杂度：O(n)；空间复杂度：O(h+1)，其中，n是二叉树的总结点数，h为二叉树的高度。
- 加1是因为最后一层的叶子结点下面还有2个空结点，因此处理空结点依然需要把它们的信息压到栈顶。
中序遍历
- 首先遍历左子树，然后访问根节点，最后遍历右子树。并且在遍历左子树和右子树时，仍然首先遍历左子树，然后访问根节点，最后遍历右子树。
代码实现
void InOrder(BTNode* b) //中序遍历
{
if (b != NULL)
{
InOrder(b->lchild);
printf("%d ", b->data);
InOrder(b->rchild);
}
}
后序遍历
- 首先遍历左子树，然后遍历右子树，最后访问根节点；并且在遍历左子树和右子树时，仍然首先遍历左子树，然后遍历右子树，最后访问根节点。
代码实现
void PostOrder(BTNode* b) //后序遍历
{
if (b != NULL)
{
PostOrder(b->lchild);
PostOrder(b->rchild);
printf("%d ", b->data);
}
}
层次遍历
- 不同于前面3种遍历方法，它是非递归的，用于一层一层地访问二叉树中的所有结点。
代码实现
void LevelOreder(BTNode *t)
{
LinkQueue *q;
InitQueue(q);
BTNode* p;
EnQueue(q, t);
while (!IsEmpty(q))
{
DeQueue(q, p);
visit(p);
if (p->lchild != NULL) EnQueue(q, p->lchild);
if (p->rchild != NULL) EnQueue(q, p->rchild);
}
}
程序分析
- 初始化一个辅助队列(链式存储结构)；
- 根节点入队；
- 若队列非空，则对头结点出队，访问该结点，并将其左、右孩子插入队尾(如果有的话)；
- 重复3，直至队列为空。
完整代码(递归)
参见：二叉树的链式存储结构
二叉树的遍历(非递归算法)
先序遍历
- 先序遍历非递归算法主要有两种设计方法：
- 由先序遍历过程可知，先访问根结点，再遍历左子树，最后遍历右子树。由于在二叉链中左、右子树是通过根结点的指针域指向的，在访问根结点后遍历左子树时会丢失右子树的地址，需要使用一个栈来临时保存左、右子树的地址。
代码实现1
void PreOrder1(BiTNode* b) //先序非递归遍历算法1
{
BiTNode* p;
SqStack* st; //定义栈指针st
InitStack(st); //初始化栈st
if (b != NULL)
{
Push(st, b); //根节点进栈
while (!EmptyStack(st)) //栈不空时循环
{
Pop(st, p); //退栈结点p并访问它
printf("%c ", p->data);
if (p->rchild != NULL) Push(st, p->rchild); //有右孩子时将其进栈
if (p->lchild != NULL) Push(st, p->lchild); //有左孩子时将其进栈
}
printf("\n");
}
DestroyStack(st); //销毁栈
}
程序分析1
- 由于栈的特点是先进后出，而先序遍历是先遍历左子树，再遍历右子树，所以当访问完一个非叶子结点后应先将其右孩子进栈，再将其左孩子进栈。
- 先序遍历顺序是根结点、左子树和右子树，所以先访问根结点b及其所有左下结点。由于在二叉链中无法由孩子找到其双亲，所以需要将这些访问过的结点进栈保存起来。此时当前栈顶结点要么没有左子树(实际上是没有左孩子)，要么左子树已遍历过，所以转向它的右子树，对右子树的处理与上述过程类似。
代码实现2
void PreOrder2(BiTNode* b)
{
BiTNode* p;
SqStack* st; //定义栈指针st
InitStack(st); //初始化栈st
p = b;
while (!EmptyStack(st) || p != NULL)
{
while (p != NULL)
{
printf("%c ", p->data);
Push(st, p);
p = p->lchild;
}
if (!EmptyStack(st))
{
Pop(st, p);
p = p->rchild;
}
}
printf("\n");
DestroyStack(st);
}
程序分析2
- 首先让p指向根结点，然后开始外循环，每一轮循环分为两个阶段，第一个阶段是沿着结点p的左下方向查找，边访向边进栈，直到最左下结点(它没有左孩子)；第二个阶段出栈一个结点p，通过让p指向它的右孩子再重复循环来遍历右子树。
- 每一轮外循环结束时，所有栈中的结点均已访问且它的左子树已遍历(或者左子树为空)，等待遍历右子树；而p指向刚刚出栈结点的右子树。显然，当栈空而且p=NULL时，表示所有结点都访问了，算法结束。
中序遍历
- 中序遍历非递归算法是在先序遍历非递归算法2的基础上修改的，中序遍历顺序是左子树、根结点、右子树。所以需要将根结点及其左下结点依次进找，但还不能访问，因为它们的左子树没有遍历。当达到根结点的最左下结点时，它是中序序列的开始结点，也是栈顶结点，出找并访问它，然后转向它的右子树，对右子树的处理与上述过程类似。
代码实现
void InOrder(BiTNode* b)
{
BiTNode* p;
SqStack* st; //定义栈指针st
InitStack(st); //初始化栈st
p = b;
while (!EmptyStack(st) || p != NULL)
{
while (p != NULL) //访问结点p及其所有坐下结点并进栈
{
Push(st, p); //结点p进栈
p = p->lchild; //移动左孩子
}
if (!EmptyStack(st)) //若栈不空
{
Pop(st, p); //出栈结点p
printf("%c ", p->data); //访问结点p
p = p->rchild; //转向处理右子树
}
}
printf("\n");
DestroyStack(st); //销毁栈
}
程序分析
- 当每一轮外循环结束时，所有栈中结点均未访问，但它的左子树已遍历(或者左子树为空)，等待访问并遍历右子树；而p指向刚刚访问结点(出栈结点)的右子树。当栈空而且p=NULL时，表示所有结点都访问了，算法结束。
后序遍历
- 后序遍历非递归算法是在中序遍历非递归算法的基础上修改的，后序遍历顺序是左子树、右子树、根结点。所以先将根结点及其左下结点依次进栈，即使栈顶结点p的左子树已遍历或为空，仍还不能访问结点p，因为它们的右子树没有遍历，只有当这样的结点的右子树已遍历完才能访问结点p。需要进一步解决以下两个问题：
- 如何判断当前处理的结点p是栈顶结点？设置一个布尔变量flag，在 do-while循环中的第一个while循环结束后开始处理栈顶结点，置flag为true；一旦转向处理右子树，置flag为 false。
- 如何判断结点p的右子树已遍历过？在一棵二叉树中，任何一棵非空子树的后序遍历序列中最后访问的一定是该子树的根结点，也就是说，若结点p的右孩子刚刚访问过，说明它的右子树已遍历完，可以访问结点p了。当然，若结点p的右孩子为空，也可以访向结点p。为此设置一个指针变量，其初始值为NULL，让它指向刚刚访问过的结点。对于正在处理的栈顶结点p，一旦p->rchild==r成立，说明结点p的左、右子树都遍历过了，将可以访问结点。
代码实现
void PostOrder(BiTNode* b)
{
BiTNode* p, * r;
bool flag;
SqStack* st; //定义一个顺序栈指针st
InitStack(st); //初始化栈st
p = b;
do {
while (p != NULL) //扫描结点p的所有左下结点并进栈
{
Push(st, p); //结点p进栈
p = p->lchild; //移到动到左孩子
}
r = NULL; //r指向刚访问的结点，初始时为空
flag = true; //flag为真表示正在处理栈顶结点
while (!EmptyStack(st) && flag)
{
GetTop(st, p); //取出当前的栈顶结点p
if (p->rchild == r) //若结点p的右孩子为空或者为刚刚访问过的结点
{
printf("%c ", p->data); //访问结点p
Pop(st, p);
r = p; //r指向刚访问过的结点
}
else
{
p = p->rchild; //转向处理其右子树
flag = false; //表示当前不是处理栈顶结点
}
}
} while (!EmptyStack(st)); //栈不空循环
printf("\n");
DestroyStack(st); //销毁栈
}
程序分析
- 当每一轮外循环结束时，所有栈中结点均未访问但它的左子树已遍历(或者左子树为空)，等待遍历其右子树并访问它；所以一旦栈空，表示没有任何需要访问的结点，算法结束。但在外循环之前没有任何结点进栈，所以外循环采用do-while循环，判断栈是否为空。
完整代码(非递归)
#include<stdio.h>
#include<malloc.h>
typedef char ElemType;
#define MaxSize 20
typedef struct BiTNode
{
ElemType data; //数据元素
struct BiTNode* lchild, * rchild; //指向左、右孩子结点
}BiTNode;
typedef struct
{
BiTNode* data[MaxSize]; //存放栈中的数据元素
int top; //存放栈顶指针
}SqStack; //顺序栈类型
bool CreateTree(BiTNode*& b) //构建二叉树
{
ElemType data;
if ((data = getchar()) == '#') b = NULL;
else
{
b = (BiTNode*)malloc(sizeof(BiTNode));
if (b == NULL) return false;
b->data = data;
CreateTree(b->lchild); //创建左子树
CreateTree(b->rchild); //创建右子树
}
return true;
}
void InitStack(SqStack*& s) //初始化栈
{
s = (SqStack*)malloc(sizeof(SqStack)); //分配一个顺序栈空间，首地址存放在s中
if (s == NULL) printf("内存分配不成功！\n");
s->top = -1; //栈顶指针置为-1
}
bool EmptyStack(SqStack* s) //判断栈是否为空
{
return s->top == -1;
}
bool Push(SqStack*& st,BiTNode *b) //进栈
{
if (st->top == MaxSize - 1) return false; //栈满的情况，即栈上溢出
st->data[++st->top] = b; //栈顶指针先增1，再将元素放在栈顶指针处
return true;
}
bool Pop(SqStack*& st, BiTNode *&b) //出栈
{
if (st->top == -1) return false; //栈空的情况，即栈下溢出
b = st->data[st->top--]; //先取栈顶元素，再使栈顶指针减1
return true;
}
bool GetTop(SqStack* st, BiTNode *&b) //取栈顶元素
{
if (st->top == -1) return false; //栈空的情况，即栈下溢出
b = st->data[st->top]; //取栈顶元素
return true;
}
void DestroyStack(SqStack*& s) //销毁栈
{
free(s);
}
void PreOrder1(BiTNode* b) //先序遍历非递归算法1
{
BiTNode* p;
SqStack* st; //定义栈指针st
InitStack(st); //初始化栈st
if (b != NULL)
{
Push(st, b); //根节点进栈
while (!EmptyStack(st)) //栈不空时循环
{
Pop(st, p); //退栈结点p并访问它
printf("%c ", p->data);
if (p->rchild != NULL) Push(st, p->rchild); //有右孩子时将其进栈
if (p->lchild != NULL) Push(st, p->lchild); //有左孩子时将其进栈
}
printf("\n");
}
DestroyStack(st); //销毁栈
}
void PreOrder2(BiTNode* b) //先序遍历非递归算法2
{
BiTNode* p;
SqStack* st; //定义栈指针st
InitStack(st); //初始化栈st
p = b;
while (!EmptyStack(st) || p != NULL)
{
while (p != NULL)
{
printf("%c ", p->data);
Push(st, p);
p = p->lchild;
}
if (!EmptyStack(st))
{
Pop(st, p);
p = p->rchild;
}
}
printf("\n");
DestroyStack(st);
}
void InOrder(BiTNode* b) //中序遍历非递归算法
{
BiTNode* p;
SqStack* st; //定义栈指针st
InitStack(st); //初始化栈st
p = b;
while (!EmptyStack(st) || p != NULL)
{
while (p != NULL) //访问结点p及其所有坐下结点并进栈
{
Push(st, p); //结点p进栈
p = p->lchild; //移动左孩子
}
if (!EmptyStack(st)) //若栈不空
{
Pop(st, p); //出栈结点p
printf("%c ", p->data); //访问结点p
p = p->rchild; //转向处理右子树
}
}
printf("\n");
DestroyStack(st); //销毁栈
}
void PostOrder(BiTNode* b) //后序遍历非递归算法
{
BiTNode* p, * r;
bool flag;
SqStack* st; //定义一个顺序栈指针st
InitStack(st); //初始化栈st
p = b;
do {
while (p != NULL) //扫描结点p的所有左下结点并进栈
{
Push(st, p); //结点p进栈
p = p->lchild; //移到到左孩子
}
r = NULL; //r指向刚访问的结点，初始时为空
flag = true; //flag为真表示正在处理栈顶结点
while (!EmptyStack(st) && flag)
{
GetTop(st, p); //取出当前的栈顶结点p
if (p->rchild == r) //若结点p的右孩子为空或者为刚刚访问过的结点
{
printf("%c ", p->data); //访问结点p
Pop(st, p);
r = p; //r指向刚访问过的结点
}
else
{
p = p->rchild; //转向处理其右子树
flag = false; //表示当前不是处理栈顶结点
}
}
} while (!EmptyStack(st)); //栈不空循环
printf("\n");
DestroyStack(st); //销毁栈
}
int main() //主函数
{
BiTNode* b;
printf("请输入元素，#表示空树：");
CreateTree(b);
printf("先序遍历非递归算法1：");
PreOrder1(b);
printf("先序遍历非递归算法2：");
PreOrder2(b);
printf("中序遍历非递归算法：");
InOrder(b);
printf("后序遍历非递归算法：");
PostOrder(b);
return 0;
}
4608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
