在二叉树的一些应用中，常常要求在树中查找具有某些特征的结点，或者对树中全部结点逐一进行某种处理。这就提出了一个遍历二叉树的问题，即如果按某条搜索路径巡访树中的每个结点，使得每个结点均被访问一次，而且仅被访问一次。“访问”的含义很广，可以是对结点作各种处理，如输出结点的信息等。遍历对于线性结构来说是一个很容易解决的问题，而对二叉树则不然，因为二叉树是一种非线性结构。
回顾二叉树的定义，我们知道二叉树可以看成是由三个部分组成的：一个根结点，根的左子树和根的右子树。因此如果能够遍历这三部分，则可以遍历整棵二叉树。如果用L、D、R分别表示遍历左子树、访问根结点、遍历右子树。那么对于二叉树的遍历次序就可以有6中方案，即L、D、R的排列组合，那么如果限制对左子树的遍历要先于对右子树的遍历，这就剩下3中情况，分别是：
- （1）访问根，遍历左子树，遍历右子树（DLR）
- （2）遍历左子树，访问根，遍历右子树（LDR）
- （3）遍历左子树，遍历右子树，访问根（LRD）
根据对根访问的不同顺序，分别成DLR为先根（序）遍历，LDR为中根（序）遍历，LRD为后根（序）遍历。
需要注意的是，这里的先序遍历、中序遍历和后序遍历是递归定义的，即在左右子树中也是按相应的规律进行遍历。
例如，如上图所示的二叉树表示下述表达式：
4 + (6 - 8 + 2 * 2)*2若先序遍历此二叉树，按访问结点的先后次序将结点排列起来，可得二叉树的先序序列为：
+ 4 * + - 6 8 * 2 2 2 （式1）类似的，中序遍历此二叉树，可得此二叉树的中序序列为：
4 + 6 - 8 + 2 * 2 * 2 （式2）后序遍历此二叉树，可得此二叉树的后序序列为：
4 6 8 - 2 2 * + 2 * + （式3）从表达式上看，式1、2、3恰好是表达式的前缀表示（波兰式）、中缀表示和后缀表示（逆波兰式）。
我们可以很简单地写出遍历二叉树的递归算法，同时，根据递归时工作栈的状态变化情况，我们也可以很简单地写出遍历二叉树的非递归算法。
每一个遍历的非递归算法都有两种思路，如果借助访问标记的话，我们可以根据递归的特点，手动地用一个栈来保存每一个结点，举例来说，先序遍历时先访问根，再访问左子树，接着访问右子树，即DLR，那么我们对于每一个结点，都按照RLD的顺序入栈，如果一个结点的左右子树已经入过栈，那么该结点视为已访问过的，下一次再遇到的话直接从栈中弹出，并且访问即可；而如果一个结点是未访问过的，则先将其弹出，再按照RLD的顺序，将其右孩子、左孩子入栈，接着自己再入栈。重复这个过程直到栈为空。这种方法实现和理解起来都比较简单。
另一种思路不需要借助访问标记，但是也要借助一个栈来实现，这种方式理解起来比上一种方法稍微有点复杂。
那么下述代码，实现了二叉树的递归与非递归的遍历方法。并且，每一种非递归方法都采用至少两种思路实现。
另外，我们是通过二叉树的顺序存储结构（即数组）来创建二叉树，与此同时，也实现了二叉树的层序遍历。
import java.util.HashMap;
import java.util.Map;
import com.gavin.datastructure.queue.ArrayQueue;
import com.gavin.datastructure.stack.ArrayStack;
/** * 实现二叉树的构建以及各种遍历 * * @author Gavin * * @param <T> */
public class BinaryTree<T> {
/** * 从顺序存储结构，即数组中构建二叉树 * * @param array * 数组 * @return 返回二叉树根结点 */
public TripleLinkedNode<T> createTreeFromArray(T[] array) {
if (array == null || array.length == 0) {
return null;
}
Map<Integer, TripleLinkedNode<T>> nodeMap = new HashMap<>();
for (int i = 0; i < array.length; i++) {
// 如果值为空，说明当前结点不存在
if (array[i] == null) {
continue;
}
TripleLinkedNode<T> currentNode = null;
if (nodeMap.containsKey(i)) {
// 当前结点已存在
currentNode = nodeMap.get(i);
} else {
// 当前结点不存在
currentNode = new TripleLinkedNode<T>(array[i]);
// 加入
nodeMap.put(i, currentNode);
}
// 设置当前结点的左孩子
if (2 * i + 1 < array.length && array[2 * i + 1] != null) {
TripleLinkedNode<T> leftNode = new TripleLinkedNode<T>(array[2 * i + 1]);
currentNode.setLeft(leftNode);
nodeMap.put(2 * i + 1, leftNode);
}
// 设置当前结点的右孩子
if (2 * i + 2 < array.length && array[2 * i + 2] != null) {
TripleLinkedNode<T> rightNode = new TripleLinkedNode<T>(array[2 * i + 2]);
currentNode.setRight(rightNode);
nodeMap.put(2 * i + 2, rightNode);
}
}
// 返回根结点root
return nodeMap.get(0);
}
/** * 访问一个结点 * * @param node */
public void visit(TripleLinkedNode<T> node) {
System.out.print(node.getData() + " ");
}
/** * 将访问标记复位为false * * @param root */
public void resetVisited(TripleLinkedNode<?> root) {
if (root == null) {
return;
}
root.setVisited(false);
resetVisited(root.getLeft());
resetVisited(root.getRight());
}
/** * 递归实现前序遍历 * * @param root */
public void preOrderTraverse(TripleLinkedNode<T> root) {
if (root == null) {
return;
}
visit(root);
preOrderTraverse(root.getLeft());
preOrderTraverse(root.getRight());
}
/** * 递归实现后续遍历 * * @param root */
public void postOrderTraverse(TripleLinkedNode<T> root) {
if (root == null) {
return;
}
postOrderTraverse(root.getLeft());
postOrderTraverse(root.getRight());
visit(root);
}
/** * 递归实现中序遍历 * * @param root */
public void inOrderTraverse(TripleLinkedNode<T> root) {
if (root == null) {
return;
}
inOrderTraverse(root.getLeft());
visit(root);
inOrderTraverse(root.getRight());
}
/** * 层序遍历 * * @param root */
public void levelOrderTraverse(TripleLinkedNode<T> root) {
// 要使用一个队列
ArrayQueue<TripleLinkedNode<T>> queue = new ArrayQueue<>();
queue.enqueue(root);
while (!queue.isEmpty()) {
TripleLinkedNode<T> currentNode = queue.dequeue();
// 访问队头结点
visit(currentNode);
// 左孩子入队
if (currentNode.hasLeft()) {
queue.enqueue(currentNode.getLeft());
}
// 右孩子入队
if (currentNode.hasRight()) {
queue.enqueue(currentNode.getRight());
}
}
}
/** * 使用访问标记的非递归前序遍历 * * @param root */
public void preOrderTraverseNoRecursionWithVisited(TripleLinkedNode<T> root) {
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
TripleLinkedNode<T> node = root;
stack.push(node);
while (!stack.isEmpty()) {
node = stack.peek();
if (node.isVisited() || (!node.hasLeft() && !node.hasRight())) {
// 已被访问过或者是叶子结点，则直接访问
visit(node);
stack.pop();
continue;
}
// 先弹出
stack.pop();
if (node.hasRight()) {
stack.push(node.getRight());
}
if (node.hasLeft()) {
stack.push(node.getLeft());
}
// 再加入
node.setVisited(true);
stack.push(node);
}
}
/** * 不使用访问标记的非递归实现前序遍历 * * @param root */
public void preOrderTraverseNoRecursionWithoutVisited(TripleLinkedNode<T> root) {
// 要用到一个栈
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
TripleLinkedNode<T> node = root;
while (node != null) {
// 向左走到底
while (node != null) {
visit(node); // 访问根结点
// 将该根结点的右孩子入栈
if (node.hasRight()) {
stack.push(node.getRight());
}
node = node.getLeft();
}
// 右子树根退栈遍历右子树
if (!stack.isEmpty()) {
node = stack.pop();
}
}
}
/** * 不使用访问标记的非递归实现前序遍历2：简单好理解 * * @param root */
public void preOrderTraverseNoRecursionWithoutVisited2(TripleLinkedNode<T> root) {
// 要用到一个栈
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
TripleLinkedNode<T> node = root;
stack.push(node);
while (!stack.isEmpty()) {
node = stack.pop();
visit(node);
if (node.hasRight()) {
stack.push(node.getRight());
}
if (node.hasLeft()) {
stack.push(node.getLeft());
}
}
}
/** * 使用访问标记的非递归中序遍历 * * @param root */
public void inOrderTraverseNoRecursionWithVisited(TripleLinkedNode<T> root) {
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
TripleLinkedNode<T> node = root;
stack.push(node);
while (!stack.isEmpty()) {
node = stack.peek();
if (node.isVisited() || (!node.hasLeft() && !node.hasRight())) {
visit(node);
stack.pop();
continue;
}
// 先弹出
stack.pop();
if (node.hasRight()) {
stack.push(node.getRight());
}
// 再加入
node.setVisited(true);
stack.push(node);
if (node.hasLeft()) {
stack.push(node.getLeft());
}
}
}
/** * 不使用访问标记的非递归实现中序遍历 * * @param root */
public void inOrderTraverseNoRecursionWithoutVisited(TripleLinkedNode<T> root) {
// 要用到一个栈
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
TripleLinkedNode<T> node = root;
while (node != null || !stack.isEmpty()) {
// 向左走到尽头
while (node != null) {
stack.push(node);
node = node.getLeft();
}
if (!stack.isEmpty()) {
// 取出根结点并访问
node = stack.pop();
visit(node);
// 转向根的右子树进行遍历
node = node.getRight();
}
}
}
/** * 使用访问标记的非递归后序遍历 * * @param root */
public void postOrderTraverseNoRecursionWithVisited(TripleLinkedNode<T> root) {
// 要用到一个栈
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
TripleLinkedNode<T> node = root;
stack.push(node);
while (!stack.isEmpty()) {
node = stack.peek();
// 如果曾经已经访问过其孩子，这里直接访问即可。或者是叶子结点的话，这里也直接访问
if (node.isVisited() || (!node.hasLeft() && !node.hasRight())) {
// 叶子结点
visit(node);
stack.pop();
continue;
}
// 先加入右孩子
if (node.hasRight()) {
stack.push(node.getRight());
}
// 再加入左孩子
if (node.hasLeft()) {
stack.push(node.getLeft());
}
// 其子结点加入栈，这里设置其访问标记为true
node.setVisited(true);
}
}
/** * 不使用访问标记的非递归后序遍历 * * @param root */
public void postOrderTraverseNoRecursionWithoutVisited(TripleLinkedNode<T> root) {
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
TripleLinkedNode<T> node = root;
while (node != null || !stack.isEmpty()) {
// 先左后右不断深入
while (node != null) {
// 将根结点入栈
stack.push(node);
if (node.hasLeft()) {
node = node.getLeft();
} else {
node = node.getRight();
}
}
if (!stack.isEmpty()) {
// 取出栈顶元素访问
node = stack.pop();
visit(node);
}
// 满足条件时，说明栈顶根结点右子树已经访问过，应出栈访问之
while (!stack.isEmpty() && stack.peek().getRight() == node) {
node = stack.pop();
visit(node);
}
// 转向栈顶根结点的右子树继续后续遍历
if (!stack.isEmpty()) {
node = stack.peek().getRight();
} else {
node = null;
}
}
}
/** * 不使用访问标记的非递归后序遍历的第二种解法：使用两个栈，简单也好理解 * * @param root */
public void postOrderTraverseNoRecursionWithoutVisited2(TripleLinkedNode<T> root) {
ArrayStack<TripleLinkedNode<T>> stack = new ArrayStack<>();
ArrayStack<TripleLinkedNode<T>> output = new ArrayStack<>();
TripleLinkedNode<T> node = root;
stack.push(node);
while (!stack.isEmpty()) {
node = stack.pop();
output.push(node);
if (node.hasLeft()) {
stack.push(node.getLeft());
}
if (node.hasRight()) {
stack.push(node.getRight());
}
}
while (!output.isEmpty()) {
visit(output.pop());
}
}
}
下面代码对当前的二叉树遍历进行测试：
import static org.junit.Assert.*;
import org.junit.Test;
public class BinaryTreeTest {
@Test
public void testCreateTreeFromArray() {
BinaryTree<String> bt = new BinaryTree<>();
String[] array = { "+", "4", "*", null, null, "+", "2", null, null, null, null, "-", "*", null, null, null,
null, null, null, null, null, null, null, "6", "8", "2", "2", null, null, null, null };
TripleLinkedNode<String> root = bt.createTreeFromArray(array);
assertEquals(11, root.getSize());
assertEquals(5, root.getHeight());
// 遍历
System.out.println("递归先序遍历：");
bt.preOrderTraverse(root);
System.out.println();
System.out.println("使用访问标记的非递归先序遍历：");
bt.preOrderTraverseNoRecursionWithVisited(root);
System.out.println();
System.out.println("不使用访问标记的非递归先序遍历1：");
bt.preOrderTraverseNoRecursionWithoutVisited(root);
// 标记复位
bt.resetVisited(root);
System.out.println();
System.out.println("不使用访问标记的非递归先序遍历2：");
bt.preOrderTraverseNoRecursionWithoutVisited2(root);
System.out.println();
System.out.println();
System.out.println("递归中序遍历：");
bt.inOrderTraverse(root);
System.out.println();
System.out.println("使用访问标记的非递归中序遍历：");
bt.inOrderTraverseNoRecursionWithVisited(root);
System.out.println();
System.out.println("不使用访问标记的非递归中序遍历：");
bt.inOrderTraverseNoRecursionWithoutVisited(root);
//标记复位
bt.resetVisited(root);
System.out.println();
System.out.println();
System.out.println("递归后序遍历：");
bt.postOrderTraverse(root);
System.out.println();
System.out.println("使用访问标记的非递归后序遍历：");
bt.postOrderTraverseNoRecursionWithVisited(root);
System.out.println();
System.out.println("不使用访问标记的非递归后序遍历1：");
bt.postOrderTraverseNoRecursionWithoutVisited(root);
bt.resetVisited(root);
System.out.println();
System.out.println("不使用访问标记的非递归后序遍历2：");
bt.postOrderTraverseNoRecursionWithoutVisited2(root);
System.out.println();
System.out.println();
System.out.println("层序遍历：");
bt.levelOrderTraverse(root);
}
}输出如下：
递归先序遍历：
+ 4 * + - 6 8 * 2 2 2
使用访问标记的非递归先序遍历：
+ 4 * + - 6 8 * 2 2 2
不使用访问标记的非递归先序遍历1：
+ 4 * + - 6 8 * 2 2 2
不使用访问标记的非递归先序遍历2：
+ 4 * + - 6 8 * 2 2 2
递归中序遍历：
4 + 6 - 8 + 2 * 2 * 2
使用访问标记的非递归中序遍历：
4 + 6 - 8 + 2 * 2 * 2
不使用访问标记的非递归中序遍历：
4 + 6 - 8 + 2 * 2 * 2
递归后序遍历：
4 6 8 - 2 2 * + 2 * +
使用访问标记的非递归后序遍历：
4 6 8 - 2 2 * + 2 * +
不使用访问标记的非递归后序遍历1：
4 6 8 - 2 2 * + 2 * +
不使用访问标记的非递归后序遍历2：
4 6 8 - 2 2 * + 2 * +
层序遍历：
+ 4 * + 2 - * 6 8 2 2可见，每个算法的结果都完全正确。
