二叉树的遍历原理
其实之前我们介绍那么多的树的定义与存储，二叉树的定义与存储等等，都是为了接下来这章做铺垫的，这个就是二叉树的遍历，因为二叉树的遍历算法是一个很基础的，但是应用又是比较广泛的算法，接下来我们就来学习什么是二叉树的遍历。
二叉树的遍历( travesing binarg tree ) 是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。
这里有两个关键词：访问和次序。
访问其实是要根据实际的需要来确定具体做什么，比如对每个结点进行相关计算， 输出打印等，它算作是一个抽象操作。在这里我们可以简单地假定就是输出结点的数据信息。
二叉树的遍历次序不同于线性结构，最多也就是从头至尾、循环、双向等简单的遍历方式。树的结点之间不存在唯一的前驱和后继关系，在访问一个结点后，下一个被访问的结点面临着不同的选择。 就像你人生的道路上，高考填志愿要面临哪个城市、哪所大学、具体专业等选择，由于选择方式的不同，遍历的次序就完全不同了。
二叉树遍历方法
二叉树的遍历方式可以很多，如果我们限制了从左到右的习惯方式，那么主要就分为四种 ：
前序遍历
规则是若二叉树为空，则空操作返回，否则先访问根结点，然后前序遍历左子树， 再前序遍历右子树（简记：根左右）。示例如下图所示，遍历的顺序为: ABDGHCEIF。
二叉树的定义是用递归的方式，所以，实现遍历算法也可以采用递归，而且极其简洁明了；当然也可以不使用递归，但是要麻烦一些。先来看看二叉树的前序遍历算法。代码如下:
public class TreeTraverse {
// 前序遍历递归实现
public static void preOrderTraverse(TreeNode biTree) {
System.out.println("遍历值为：" + biTree.value);
TreeNode leftTree = biTree.left;// 先判断左子树是否存在，存在就继续调用自身找左子树，直到不存在左子树
if (leftTree != null) {
preOrderTraverse(leftTree);
}
TreeNode rightTree = biTree.right;// 再判断右子树是否存在，存在就继续调用自身找右子树，直到不存在右子树
if (rightTree != null) {
preOrderTraverse(rightTree);
}
}
// 前序遍历非递归实现
public static void preOrder(TreeNode biTree) {
Stack<TreeNode> stack = new Stack<TreeNode>();// 建立一个树结点的栈
while (biTree != null || !stack.isEmpty()) {
while (biTree != null) {// 通过while判断左子树是否为空，不为空继续循环
System.out.println(biTree.value);
stack.push(biTree);
biTree = biTree.left;
}
if (!stack.isEmpty()) {// 左子树出栈，将右子树赋值，继续查找
biTree = stack.pop();
biTree = biTree.right;
}
}
}
public static void main(String args[]) {
TreeNode[] node = new TreeNode[10];// 以数组形式生成一棵完全二叉树
for (int i = 0; i < 10; i++) {
node[i] = new TreeNode(i);
}
for (int i = 0; i < 10; i++) {
if (i * 2 + 1 < 10)
node[i].left = node[i * 2 + 1];
if (i * 2 + 2 < 10)
node[i].right = node[i * 2 + 2];
}
preOrderTraverse(node[0]);
}
}
/**
* 结点类
*/
class TreeNode
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value) {
this.value = value;
}
}
中序遍历
规则是若树为空，则空操作返回，否则从根结点开始(注意并不是先访问根结点) ，中序遍历根结点的左子树，然后是访问根结点，最后中序遍历右子树（简记：左根右）。 如下图所示， 遍历的顺序为 : GDHBAEICF。
那么二叉树的中序遍历算法是如何呢?哈哈，别以为很复杂，它和前序遍历算法仅仅只是代码的顺序上的差异。示例代码如下：
public class InOrderTraverse {
public static void main(String[] args) {
NewTreeNode[] node = new NewTreeNode[10];// 建立一个10个数字的二叉树
for (int i = 0; i < 10; i++) {
node[i] = new NewTreeNode(i);
}
for (int i = 0; i < 10; i++) {
if (i * 2 + 1 < 10)
node[i].left = node[i * 2 + 1];
if (i * 2 + 2 < 10)
node[i].right = node[i * 2 + 2];
}
inOrderTreeTraverse(node[0]);// 进行中序递归遍历
}
// 中序遍历递归算法
public static void inOrderTreeTraverse(NewTreeNode biTree) {
if (biTree == null) {
return;
} else {
inOrderTreeTraverse(biTree.left);
System.out.println("遍历值为：" + biTree.value);
inOrderTreeTraverse(biTree.right);
}
}
// 中序遍历非递归算法
public static void inOrderTraverse(NewTreeNode biTree) {
Stack<NewTreeNode> stack = new Stack<NewTreeNode>();// 用栈来存储所要输出的结点值
while (biTree != null || !stack.isEmpty()) {
while (biTree != null) {
stack.push(biTree);
biTree = biTree.left;
}
if (!stack.isEmpty()) {
biTree = stack.pop();
System.out.println(biTree.value);
biTree = biTree.right;
}
}
}
}
/**
* 结点类
*/
class NewTreeNode {
int value;
NewTreeNode left;
NewTreeNode right;
NewTreeNode(int value) {
this.value = value;
}
}
后序遍历(难点)
规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点（简记：左右根）。 如下图所示，遍历的顺序为： GHDBIEFCA。
算法核心思想：
首先要搞清楚先序、中序、后序的非递归算法共同之处：用栈来保存先前走过的路径，以便可以在访问完子树后,可以利用栈中的信息,回退到当前节点的双亲节点,进行下一步操作。
后序遍历的非递归算法是三种顺序中最复杂的，原因在于，后序遍历是先访问左、右子树,再访问根节点，而在非递归算法中，利用栈回退到时，并不知道是从左子树回退到根节点，还是从右子树回退到根节点，如果从左子树回退到根节点，此时就应该去访问右子树，而如果从右子树回退到根节点，此时就应该访问根节点。所以相比前序和后序，必须得在压栈时添加信息，以便在退栈时可以知道是从左子树返回，还是从右子树返回进而决定下一步的操作。示例代码如下：
public class PostOrderTraverse {
public static void main(String[] args) {
NewTreeNode2[] node = new NewTreeNode2[10];// 构建一个10个节点的二叉树
for (int i = 0; i < 10; i++) {
node[i] = new NewTreeNode2(i);
}
for (int i = 0; i < 10; i++) {
if (i * 2 + 1 < 10) {
node[i].left = node[i * 2 + 1];
}
if (i * 2 + 2 < 10) {
node[i].right = node[i * 2 + 2];
}
}
postOrderTreeTra(node[0]);
}
/**
* 构建后序遍历的递归方法
*
* @param treeNode
*/
public static void postOrderTreeTra(NewTreeNode2 treeNode) {
if (treeNode == null) {
return;
} else {
postOrderTreeTra(treeNode.left);
postOrderTreeTra(treeNode.right);
System.out.println(treeNode.value);
}
}
/**
* 构建后序遍历的非递归方法
*
* @param treeNode
*/
public static void postOrderTra(NewTreeNode2 treeNode) {
int left = 1;// 在辅助栈里表示左节点
int right = 2;// 在辅助栈里表示右节点
Stack<NewTreeNode2> stack = new Stack<NewTreeNode2>();
Stack<Integer> stack2 = new Stack<Integer>();// 辅助栈，用来判断子节点返回父节点时处于左节点还是右节点。
while (treeNode != null || !stack.empty()) {
while (treeNode != null) {// 将节点压入栈1，并在栈2将节点标记为左节点
stack.push(treeNode);
stack2.push(left);
treeNode = treeNode.left;
}
while (!stack.empty() && stack2.peek() == right) {// 如果是从右子节点返回父节点，则任务完成，将两个栈的栈顶弹出
stack2.pop();
System.out.println(stack.pop().value);
}
if (!stack.empty() && stack2.peek() == left) {// 如果是从左子节点返回父节点，则将标记改为右子节点
stack2.pop();
stack2.push(right);
treeNode = stack.peek().right;
}
}
}
}
/**
* 构建树节点类
*/
class NewTreeNode2 {
int value;
NewTreeNode2 left;
NewTreeNode2 right;
public NewTreeNode2(int value) {
this.value = value;
}
}
层序遍历
规则是若树为空， 则空操作返回，否则从树的第一层，也就是根结点开始访问， 从上而下逐层遍历，在同一层中， 按从左到右的顺序对结点逐个访问。如下图所示，遍历的顺序为：ABCDEFGHI。
与树的前中后序遍历的DFS思想不同，层次遍历用到的是BFS思想。一般DFS用递归去实现（也可以用栈实现），BFS需要用队列去实现。
层次遍历的步骤是：
1.对于不为空的结点，先把该结点加入到队列中
2.从队中拿出结点，如果该结点的左右结点不为空，就分别把左右结点加入到队列中
3.重复以上操作直到队列为空
示例代码如下：
public static void levelOrder(TreeNode biTree)
{//层次遍历
if(biTree == null)
return;
LinkedList<TreeNode> list = new LinkedList<TreeNode>();
list.add(biTree);
TreeNode currentNode;
while(!list.isEmpty())
{
currentNode = list.poll();
System.out.println(currentNode.value);
if(currentNode.left != null)
list.add(currentNode.left);
if(currentNode.right != null)
list.add(currentNode.right);
}
}
有朋友会说，研究这么多遍历的方法干什么呢?
我们用图形的方式来表现树的结构，应该说是非常直观和容易理解，但是对于计算机来说，它只有循环、判断等方式来处理，也就是说，它只会处理线性序列，而我们刚才提到的四种遍历方法，其实都是在把树中的结点变成某种意义的线性序列，这就给程序的实现带来了好处。
另外不同的遍历提供了对结点依次处理的不同方式，可以在遍历过程中对结点进行各种处理。
遍历推导(重点)
有一种题目为了考查你对二叉树遍历的掌握程度，是这样出题的。已知一棵二叉树的前序遍历序列为 ABCDEF，中序遍历序列为 CBAEDF，请问这棵二叉树的后序遍历结果是多少?
对于这样的题目，如果真的完全理解了前中后序的原理，是不难的。
三种遍历都是从根结点开始，前序遍历是先打印再递归左和右。所以前序遍历序列为 ABCDEF， 第一个字母是 A 被打印出来，就说明 A 是根结点的数据。再由中序遍历序列是 CBAEDF，可以知道 C 和 B 是 A 的左子树的结点， E、D、F 是A的右子树的结点，如下图所示。
然后我们看前序中的 C 和 B， 它的顺序是ABCDEF，是先打印 B 后打印 C，所以 B 应该是 A 的左孩子，而 C 就只能是 B 的孩子，此时是左还是右孩子还不确定。再看中序序列是CBAEDF， C 是在 B 的前面打印，也就说明 C 是 B 的左孩子，否则就是右孩子了，如下图所示。
再看前序中的 E、D、F，它的顺序是 ABCDEF，那就意味着 D 是 A 结点的右孩 子， E 和 F 是 D 的子孙，注意，它们中有一个不一定是孩子，还有可能是孙子的。 再来看中序序列是 CBAEDF，由于 E 在 D 的左侧，而 F 在右侧，所以可以确定 E 是 D 的左孩子 ， F 是 D 的右孩子。因此最终得到的二叉树是下图所示。
为了避免推导中的失误，你最好在心中递归遍历，检查一下这棵树的前序和中序遍历序列是否与题目中的相同。
已经复原了二叉树，要获得它的后序遍历结果就是易如反掌，结果是 CBEFDA.
但其实，如果同学们足够熟练，不用画这棵二叉树，也可以得到后序的结果，因为刚才判断了 A 结点是根结点，那么它在后序序列中 ， 一定是最后一个。刚才推导出 C 是 B 的左孩子，而 B 是 A 的左孩子，那就意味着后序序列的前两位一定是CB。 同样的办法也可以得到 EFD 这样的后序顺序，最终就自然的得到 CBEFDA 这样的序列，不用在草稿上面树状图了。
反过来，如果我们的题目是这样: 二叉树的中序序列是 ABCDEFG，后序序列是 BDCAFGE ，求前序序列。
这次简单点，由后序的 BDCAPGE，得到 E 是根结点，因此前序首字母是 E。
于是根据中序序列分为两棵树 ABCD 和 FG，由后序序列的 BDCAFGE， 知道 A 是 E 的左孩子，前序序列目前分析为 EA。
再由中序序列的 ABCDEFG ，知道 BCD 是 A 结点的右子孙，再由后序序列的 BDCAFGE 知道 C 结点是A 结点的右孩子，前序序列目前分析得到 EAC。
中序序列 ABCDEFG ，得到 B 是 C 的左孩子， D 是 C 的右孩子，所以前序序列目前分析结果为 EACBD.
由后序序列 BDCAFGE， 得到 G 是 E 的右孩子，于是 F 就是 G 的孩子。如果你是在考试时做这道题目，时间就是分数、名次、学历，那么你根本不需关心 F 是 G 的左还是右孩子，前序遍历序列的最终结果就是 EACBDGF。
不过细细分析，根据中序序列 ABCDEFG，是可以得出 F 是 G 的左孩子。
从这里我们也得到两个二叉树遍历的性质。
• 己知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树。
• 已知后序遍历序列和中序遍历序列，可以唯一确定一棵二叉树。
但要注意了，已知前序和后序遍历，是不能确定一棵二叉树的， 原因也很简单， 比如前序序列是 ABC，后序序列是 CBA。 我们可以确定 A 一定是根结点，但接下来， 我们无法知道，哪个结点是左子树，哪个是右子树。这棵树可能有如图所示的四种可能。
270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
