简介
遍历二叉树就是按照某种顺序，将树中的结点都枚举一遍，且每个结点仅仅访问一次。因为树不是线性的结构，遍历不像线性表那样简单，因此他的遍历需要特点的算法来完成。
从某种角度讲，对二叉树的遍历就是将树形结构转换为线性结构的操作。
二叉树的遍历方法主要有如下几种：
- 先序遍历：先访问root结点，再先序遍历左子树，再先序遍历右子树。
- 中序遍历：先中序遍历左子树，再访问root结点，再中序遍历右子树。
- 后序遍历：先后序遍历左子树，再后序遍历右子树，再访问root结点。
- 层遍历：从上到下，从左到右，一层一层的遍历结点。
提示：
1、大多数情况下，我们总是习惯 先左后右。遍历的时候，左子树总是先于右子树，这种策略记为LR，相反的策略记为RL。本文中默认是采用LR。
2、 先序遍历，中序遍历，后序遍历都属于深度优先遍历。层遍历则属于广度优先遍历。深度优先遍历需要用栈实现（调用栈或者辅助栈），而广度优先遍历则需要用队列实现。
3、所谓的先、中、后，都是对于访问root结点的顺序来定义的。
构造一个简单的链式二叉树
先通过硬编码构建一个简单的下图所示的链式二叉树，后续的例子都是以这个为基础的。
A
/
B C
/
D E
class LinkedBinaryTree { /** * 静态内部类，结点类。 * */ private static class Node<T> { private T element; private final Node<T> left; private final Node<T> right; public Node(T element , Node<T> left , Node<T> right) { this.element = element; this.left = left; this.right = right; } @SuppressWarnings("unused") public T getElement(){ return element; } @SuppressWarnings("unused") public void setElement(T element){ this.element = element; } public Node<T> getLeft(){ return left; } public Node<T> getRight(){ return right; } @Override public String toString(){ return element.toString(); } } // class Node end private Node<Character> root = null; //root public LinkedBinaryTree() { creatTree(); } /** * 通过硬编码构造一个二叉树 * */ private void creatTree() { /******************* A / B C / D E *********************/ Node<Character> nodeC = new Node<Character>('C', null, null); Node<Character> nodeD = new Node<Character>('D', null, null); Node<Character> nodeE = new Node<Character>('E', null, null); Node<Character> nodeB = new Node<Character>('B', nodeD, nodeE); root = new Node<Character>('A', nodeB, nodeC); } }
定义一个遍历结点访问者接口
/** * 遍历的访问者接口。 * 任何需要访问结点的类都需要实现这个接口,并通过函数visit实现遍历逻辑。 * */ interface Visitor<T> { void visit(T element); }
因此我们的遍历函数就可以定义成这样的形式： public void xxxorderTraverse(Visitor<Character> visitor )
先序遍历
先序遍历：
先序遍历的特点是：对于任何一个结点，总是先访问这个结点本身，再去访问他的各个子树。
先序遍历的访问的第一个结点一定是整个树的root结点。
它不仅仅是二叉树特有的遍历方法，它对普通的一般树（generic tree）也适用，当用于遍历一般树时算法如下。
preorder(T,root): //T 是遍历的树对象，root是T的根结点。 visit(root); for each child w of root in T do preorder(T,w);
以下是针对二叉树的先序遍历算法。
递归伪代码（摘自维基百科）
preorder(node) if (node = null) return visit(node) preorder(node.left) //这里可以做一下优化：先判断node.left是否不为null，再递归调用：preorder() preorder(node.right) //这里可以做一下优化：先判断node.right是否不为null，再递归调用：preorder()
非递归伪代码（摘自维基百科）
preorder(node) if (node = null) return s ← empty stack s.push(node) while (not s.isEmpty()) node ← s.pop() visit(node) //右子树先压栈，左子树再压栈。这样下一次出栈的时候，就先遍历左子树。 if (node.right ≠ null) s.push(node.right) if (node.left ≠ null) s.push(node.left)
代码实现（Java）
private void _preorderTraverseRecursive(Node<Character> root , Visitor<Character> visitor ) { if(root == null) return ; visitor.visit(root.getElement()); //访问当前root结点 _preorderTraverseRecursive(root.getLeft(),visitor); //访问左子树 _preorderTraverseRecursive(root.getRight(),visitor);//访问右子树 } public void preorderTraverseRecursive(Visitor<Character> visitor) { _preorderTraverseRecursive(root,visitor); }
/******************************************************************/
public void preorderTraverseLoop(Visitor<Character> visitor) { if(root == null) return ; Deque<Node<Character>> stack = new LinkedList<Node<Character>>(); //使用双端队列代表栈 stack.push(root); while(!stack.isEmpty()) { Node<Character> node = stack.pop(); visitor.visit(node.getElement()); if(node.getRight()!=null) { stack.push(node.getRight()); } if(node.getLeft()!=null) { stack.push(node.getLeft()); } } }
中序遍历
中序遍历：
对于LR中序遍历，第一个被访问的结点一定是树的最左边的那个结点。
对于RL中序遍历，第一个被访问的结点一定是树的最右边的那个结点。
中序遍历一般只针对二叉树。
递归伪代码（摘自维基百科）
inorder(node) if (node = null) return inorder(node.left) visit(node) inorder(node.right)
非递归伪代码（摘自维基百科）
inorder(node) s ← empty stack while (not s.isEmpty() or node ≠ null) if (node ≠ null) s.push(node) node ← node.left else node ← s.pop() visit(node) node ← node.right
private void _inorderTraverseRecursive(Node<Character> root , Visitor<Character> visitor ) { if(root == null) return ; _inorderTraverseRecursive(root.getLeft() , visitor); visitor.visit(root.getElement()); _inorderTraverseRecursive(root.getRight() , visitor); } public void inorderTraverseRecursive(Visitor<Character> visitor) { _inorderTraverseRecursive(root, visitor); } /** * 非递归的中序遍历 * */ public void inorderTraverseLoop(Visitor<Character> visitor) { Deque<Node<Character>> stack = new LinkedList<Node<Character>>(); //使用双端队列代表栈 Node<Character> node = root; while(!stack.isEmpty() || node!=null) { if(node!=null) { stack.push(node); node = node.getLeft(); } else { node = stack.pop(); visitor.visit(node.getElement()); node = node.getRight(); } } }
后序遍历
后序遍历：
后序遍历最后一个被访问的结点一定是整个树的root结点。
后序遍历的特点是：对于任何一个结点，总是先访问这个结点的各个子树，再去访问这个结点本身。
它不仅仅是二叉树特有的遍历方法，它对普通的一般树（generic tree）也适用，当用于遍历一般树时算法如下。
postorder(T,root): //T 是遍历的树对象，root是T的根结点。 for each child w of root in T do postorder(T,w); visit(root);
后序遍历是很有作用的。
例如，我们要统计一个文件夹的占用空间大小，用内部结点表示文件夹，用叶子结点表示文件。则应该先去统计这个文件夹下的所有的文件以及子文件夹的大小，才能得出这个顶层文件夹的大小，使用后序遍历就可以实现。
又例如，当二叉树使用二叉链表存储，我们在执行销毁操作时，必须先销毁一个结点的左右子树，再销毁这个结点本身，就可以使用后序遍历实现。
后序遍历二叉树的算法：
递归伪代码（摘自维基百科）
postorder(node) if (node = null) return postorder(node.left) postorder(node.right) visit(node)
非递归伪代码（摘自维基百科）
postorder(node) s ← empty stack lastNodeVisited ← null while (not s.isEmpty() or node ≠ null) if (node ≠ null) s.push(node) node ← node.left else peekNode ← s.peek() // if right child exists and traversing node from left child, then move right if (peekNode.right ≠ null and lastNodeVisited ≠ peekNode.right) node ← peekNode.right else visit(peekNode) lastNodeVisited ← s.pop()
private void _postorderTraverseRecursive(Node<Character> root , Visitor<Character> visitor) { if(root == null) return ; _postorderTraverseRecursive(root.getLeft(), visitor); _postorderTraverseRecursive(root.getRight(),visitor); visitor.visit(root.getElement()); } public void postorderTraverseRecursive(Visitor<Character> visitor) { _postorderTraverseRecursive(root,visitor); } /** * 后序遍历非递归实现 * */ public void postorderTraverseLoop(Visitor<Character> visitor) { Deque<Node<Character>> stack = new LinkedList<Node<Character>>(); //使用双端队列代表栈 Node<Character> lastNodeVisited = null , peekNode =null; Node<Character> node = root; while(!stack.isEmpty() || node !=null) { if(node!=null) { stack.push(node); node = node.getLeft(); } else { peekNode = stack.peek(); if(peekNode.getRight() != null && lastNodeVisited!= peekNode.getRight()) node = peekNode.getRight(); else { visitor.visit(peekNode.getElement()); lastNodeVisited = stack.pop(); } } } }
层遍历
层遍历：对应图的广度优先遍历。层遍历也适用于一般树（generic tree）。
伪代码（摘自维基百科）
levelorder(root) q ← empty queue q.enqueue(root) while (not q.isEmpty()) node ← q.dequeue() visit(node) if (node.left ≠ null) q.enqueue(node.left) if (node.right ≠ null) q.enqueue(node.right)
public void levelorderTraverseLoop(Visitor<Character> visitor) { Deque<Node<Character>> queue = new LinkedList<>(); Node<Character> node = null; queue.addLast(root); //入队 while(! queue.isEmpty()) { node = queue.removeFirst(); //出队 visitor.visit(node.getElement()); if(node.getLeft()!=null) queue.addLast(node.getLeft()); if(node.getRight()!=null) queue.addLast(node.getRight()); } }
给一个二叉树的图，如何快速准确的写出 先、中、后遍历序列？
以下方法均由博主亲自实践总结。希望能帮助大家。
方法1：按照调用栈的流程写出函数递归调用过程，然后即可得出遍历序列。以下用先序遍历举例。其它的同理。
方法2：使用画图的小技巧轻松解决。
动画演示：以中序遍历为例
提示：这个方法中，如果使用的是RL 顺序，则需要做如下修改：
1、需要从行走路径末尾往前走，也就是从root结点的右边开始”行走“
2、将先序点和后序点交换位置：先序点位于结点的右边，后序点位于结点的左边。
如何由【中序+先序】或者【中序+后序】遍历画出树的形态？
提示：这种题，一定要给出中序遍历，否则是不能确定的。
前面我已经提到了不同遍历方法的规律：
1、先序遍历的访问的第一个结点一定是整个树的root结点。
2、后序遍历最后一个被访问的结点一定是整个树的root结点。
3、对于LR中序遍历，第一个被访问的结点一定是树的最左边的那个结点。
对于RL中序遍历，第一个被访问的结点一定是树的最右边的那个结点。
技巧提示：重复以下步骤
1、先由先序（或者后序）确定root结点。（先后确定根结点）
2、根据root结点和中序划分左右子树。 （root中序分两边）
题目：
前序遍历: GDAFEMHZ
中序遍历: ADEFGHMZ
写出后序遍历。
解：
首先，由 【前序遍历: GDAFEMHZ】确定root为G，再由root和【中序遍历: ADEFGHMZ】，确定 ADEF是G的左子树结点，HMZ是G的右子树结点。
然后，只看左子树【ADEF】，同样先由【前序遍历: DAFE 】 确定root结点为D ， 再由 root 和【中序遍历: ADEF】 确定A是D的左子树，FE是A的右子树。
........如此重复，即可画出树的图形。
