前言:在递归遍历的代码中,我们只需要不断调用函数自身,就可以实现遍历。要写出二叉树的非递归算法,主要任务就是用自己定义的栈来代替系统栈的功能。
完整代码见文章末尾
DFS-先序-非递归算法(一)
第一种先序算法理解起来比较简单,
以下图这个比较简单的二叉树为例:
此算法的循环跳出条件是:栈不为空(括号中为栈的当前状态)。
-
(栈顶|空|栈底)首先需要根节点(1)入栈,开始循环;
-
(栈顶|1|栈底)出栈,访问出栈元素(1),将(1)的右孩子(4)入栈,将(1)的左孩子(2)入栈;
PS:右孩子先入栈,左孩子后入栈,是由于栈后进先出的特殊结构,后入栈的左孩子会被优先访问,正好符合先序遍历“先左后右”的特点。
-
(栈顶|2 4|栈底)出栈,访问出栈元素(2),将(2)的右孩子(5)入栈,将(2)的左孩子(3)入栈;
-
(栈顶|3 5 4|栈底)出栈,访问出栈元素(3),(3)无右孩子,不做操作,(3)无左孩子,不做操作;
-
(栈顶|5 4|栈底)出栈,访问出栈元素(5),(5)无右孩子,不做操作,(5)无左孩子,不做操作;
-
(栈顶|4|栈底)出栈,访问出栈元素(4),(4)无右孩子,不做操作,(4)无左孩子,不做操作;
-
此时栈为空,算法结束。
最终访问元素的次序为:1、2、3、5、4。
代码如下:
void preorderNonrecursion1(BTNode *bt) // 深度优先非递归算法(一)
{
if(bt != NULL) // 二叉树不为空时执行
{
BTNode *Stack[50]; // 定义一个栈
int top = -1; // 初始化栈
BTNode *p; // 临时节点p
Stack[++top] = bt; // 根节点入栈
while (top != -1)
{
p = Stack[top--]; // 栈顶元素出栈
cout << p->data << ' '; // 访问栈顶节点
if(p->rchild != NULL) // 若栈顶节点的存在右孩子
{
Stack[++top] = p->rchild; // 右孩子入栈
}
if(p->lchild != NULL) // 若栈顶节点的存在左孩子
{
Stack[++top] = p->lchild; // 左孩子入栈
}
}
cout << endl;
}
}
DFS-先序-非递归算法(二)
比上一种先序方法稍难,但其实原理也很容易理解。
此算法的循环跳出条件是:栈不为空且当前节点不为空(括号中为栈的当前状态)。
该算法在进栈、出栈的过程中可能会出现栈空的状态,但此时其实遍历还没有结束,所以需要添加一个 “p非空” 的条件来维持循环的进行。
-
(栈顶|空|栈底)访问节点(1),节点(1)入栈,连续访问左子树开始,准备访问当前节点(1)的左孩子(2);
-
(栈顶|1|栈底)访问节点(2),节点(2)入栈,准备访问当前节点(2)的左孩子(3);
-
(栈顶|2 1|栈底)访问节点(3),节点(3)入栈,准备访问当前节点(3)的左孩子(^);
-
(栈顶|3 2 1|栈底)节点(3)的左孩子为空, 连续访问左子树结束,栈顶出栈(3),准备访问当前节点(3)的右孩子(^);
-
(栈顶|2 1|栈底)节点(3)的右孩子为空,栈顶出栈(2),准备访问当前节点(2)的右孩子(5);
-
(栈顶|1|栈底)访问节点(5),节点(5)入栈,连续访问左子树开始,准备访问当前节点(5)的左孩子(^);
-
(栈顶|5 1|栈底)节点(5)的左孩子为空,连续访问左子树结束,栈顶出栈(5),准备访问当前节点(5)的右孩子(^);
-
(栈顶|1|栈底)节点(5)的右孩子为空,栈顶出栈(1),准备访问当前节点(1)的右孩子(4);
此时栈已经出现了空的状态,但其实遍历还没有结束也不能结束,所以整个算法循环还需要添加一个 “p非空” 的条件来维持循环的进行。
-
(栈顶|空|栈底)访问节点(4),节点(4)入栈,连续访问左子树开始,准备访问当前节点(4)的左孩子(^);
-
(栈顶|空|栈底)节点(4)的左孩子为空,连续访问左子树结束,准备访问当前节点(4)的右孩子(^);
-
(栈顶|空|栈底)当访问到节点(4)的右孩子时,该节点为空,此时栈也为空,算法结束。
最终访问元素的次序为:1、2、3、5、4。
非递归先序代码如下:
void preorderNonrecursion2(BTNode *bt) // 深度优先前序非递归算法(二)
{
if(bt != NULL) // 二叉树不为空时执行
{
BTNode *Stack[50]; // 定义一个栈
int top = -1; // 初始化栈
BTNode *p = bt; // 临时节点p
while (top != -1 || p != NULL)
{
while (p != NULL)
{
cout << p->data << ' '; // 访问栈顶节点
Stack[++top] = p; // 当前节点入栈
p = p->lchild;
}
// 当前节点没有左孩子时
if(top != -1) // 在栈不为空的情况下
{
p = Stack[top--]; // 栈顶元素出栈
p = p->rchild;
}
}
cout << endl;
}
}
DFS-中序-非递归算法
如果你还没有搞先序算法的话,建议多读几遍上面的例子再接着看。
如果你已经完全明白了上面的算法(二),那么中序非递归对你来说会非常简单,只不过是访问元素的位置换了一个地方。
对比一下「中序」和「先序」的代码,一目了然:
非递归中序代码如下:
void inorderNonrecursion(BTNode *bt) // 深度优先中序非递归遍历算法
{
if(bt != NULL) // 二叉树不为空时执行
{
BTNode *Stack[50]; // 定义一个栈
int top = -1; // 初始化栈
BTNode *p = bt; // 临时节点p
// 中序遍历可能出现栈为空但二叉树还未遍历完成的情况
// 所以需要两个判断条件结合
while (top != -1 || p != NULL)
{
while(p != NULL) // 优先访问当前节点的左孩子(如果存在)
{
Stack[++top] = p;
p = p->lchild;
}
if(top != -1) // 在栈不为空的情况下
{
p = Stack[top--]; // 栈顶元素出栈
cout << p->data << ' '; // 访问栈顶节点
p = p->rchild;
}
}
cout << endl;
}
}
DFS-后序-非递归算法
后续非递归的算法非常巧妙,我们先手工写一下遍历序列看看。
-
先序非递归遍历:1、2、3、5、4
-
将先序非递归中对左右子树的遍历交换顺序:1、4、2、5、3(逆后序遍历)
逆后序遍历指的是:将先序遍历的左、右子树遍历顺序交换的遍历方式。
-
将(2)的结果逆序:3、5、2、4、1
-
后序非递归遍历:3、5、2、4、1
似乎发现了他们之间的一些联系:我们先把先序遍历中左右子树的遍历顺序交换得到逆后序遍历,再将逆后序遍历的结果逆序,就得到了后序遍历的结果。
因此我们需要两个栈,一个栈stack1用来辅助做逆后序遍历,并将结果序列压入另一个栈stack2,然后将stack2中的元素全部出栈(逆序),所得到的序列即为后序遍历序列。
由于先序遍历的过程我们已经梳理过,这里直接上代码:
代码和先序遍历只有一点不同,可以对比着看。
void postorderNonrecursion(BTNode *bt) // 深度优先后序非递归算法
{
if(bt != NULL) // 二叉树不为空时执行
{
// 定义两个栈
BTNode *Stack1[50]; // 辅助做逆后序遍历
int top1 = -1;
BTNode *Stack2[50]; // 存储最终结果
int top2 = -1;
BTNode *p; // 临时节点p
Stack1[++top1] = bt; // 根节点入栈
while (top1 != -1)
{
p = Stack1[top1--]; // 栈顶元素出栈
Stack2[++top2] = p; // 访问栈顶节点 存储到结果栈2
if(p->lchild != NULL) // 若栈顶节点的存在右孩子
{
Stack1[++top1] = p->lchild; // 右孩子入栈
}
if(p->rchild != NULL) // 若栈顶节点的存在左孩子
{
Stack1[++top1] = p->rchild; // 左孩子入栈
}
}
while(top2 != -1) // 输出结果
{
p = Stack2[top2--]; // 出栈序列即为后序遍历序列
cout << p->data << ' ';
}
cout << endl;
}
}
完整代码运行结果:
完整可运行代码:
#include <stdio.h>
#include <iostream>
using namespace std;
typedef struct BTNode // 定义二叉树的节点
{
char data; // 节点数据类型
struct BTNode *lchild; // 左孩子
struct BTNode *rchild; // 右孩子
}BTNode;
BTNode *createBinaryTree() // 前序递归创建二叉树
{
BTNode *p;
char ch;
cin >> ch;
if(ch == '#')
{
p = NULL;
}
else
{
p = (BTNode*)malloc(sizeof(BTNode));
p->data = ch;
p->lchild = createBinaryTree();
p->rchild = createBinaryTree();
}
return p;
}
void preorderNonrecursion1(BTNode *bt) // 深度优先前序非递归算法(一)
{
if(bt != NULL) // 二叉树不为空时执行
{
BTNode *Stack[50]; // 定义一个栈
int top = -1; // 初始化栈
BTNode *p; // 临时节点p
Stack[++top] = bt; // 根节点入栈
while (top != -1)
{
p = Stack[top--]; // 栈顶元素出栈
cout << p->data << ' '; // 访问栈顶节点
if(p->rchild != NULL) // 若栈顶节点的存在右孩子
{
Stack[++top] = p->rchild; // 右孩子入栈
}
if(p->lchild != NULL) // 若栈顶节点的存在左孩子
{
Stack[++top] = p->lchild; // 左孩子入栈
}
}
cout << endl;
}
}
void preorderNonrecursion2(BTNode *bt) // 深度优先前序非递归算法(二)
{
if(bt != NULL) // 二叉树不为空时执行
{
BTNode *Stack[50]; // 定义一个栈
int top = -1; // 初始化栈
BTNode *p = bt; // 临时节点p
while (top != -1 || p != NULL)
{
while (p != NULL)
{
cout << p->data << ' '; // 访问栈顶节点
Stack[++top] = p; // 当前节点入栈
p = p->lchild;
}
// 当前节点没有左孩子时
if(top != -1) // 在栈不为空的情况下
{
p = Stack[top--]; // 栈顶元素出栈
p = p->rchild;
}
}
cout << endl;
}
}
void inorderNonrecursion(BTNode *bt) // 深度优先中序非递归遍历算法
{
if(bt != NULL) // 二叉树不为空时执行
{
BTNode *Stack[50]; // 定义一个栈
int top = -1; // 初始化栈
BTNode *p = bt; // 临时节点p
// 中序遍历可能出现栈为空但二叉树还未遍历完成的情况
// 所以需要两个判断条件结合
while (top != -1 || p != NULL)
{
while(p != NULL) // 优先访问当前节点的左孩子(如果存在)
{
Stack[++top] = p; // 入栈
p = p->lchild;
}
if(top != -1) // 在栈不为空的情况下
{
p = Stack[top--]; // 栈顶元素出栈
cout << p->data << ' '; // 访问栈顶节点
p = p->rchild;
}
}
cout << endl;
}
}
void postorderNonrecursion(BTNode *bt) // 深度优先后序非递归算法
{
if(bt != NULL) // 二叉树不为空时执行
{
// 定义两个栈
BTNode *Stack1[50]; // 辅助做逆后序遍历
int top1 = -1;
BTNode *Stack2[50]; // 存储最终结果
int top2 = -1;
BTNode *p; // 临时节点p
Stack1[++top1] = bt; // 根节点入栈
while (top1 != -1)
{
p = Stack1[top1--]; // 栈顶元素出栈
Stack2[++top2] = p; // 访问栈顶节点 存储到结果栈2
if(p->lchild != NULL) // 若栈顶节点的存在右孩子
{
Stack1[++top1] = p->lchild; // 右孩子入栈
}
if(p->rchild != NULL) // 若栈顶节点的存在左孩子
{
Stack1[++top1] = p->rchild; // 左孩子入栈
}
}
while(top2 != -1) // 输出结果
{
p = Stack2[top2--]; // 出栈序列即为后序遍历序列
cout << p->data << ' ';
}
cout << endl;
}
}
int main()
{
cout << "开始创建二叉树(输入用例:123##5##4##)" << endl;
BTNode *root = NULL;
root = createBinaryTree();
cout << "二叉树建立成功!" << endl;
cout << "深度优先先序非递归遍历二叉树(1):" << endl;
preorderNonrecursion1(root);
cout << "深度优先先序非递归遍历二叉树(2):" << endl;
preorderNonrecursion2(root);
cout << "深度优先中序非递归遍历二叉树:" << endl;
inorderNonrecursion(root);
cout << "深度优先后序非递归遍历二叉树:" << endl;
postorderNonrecursion(root);
return 0;
}