1、背景
二叉树作为一个重要的数据结构，在实际生产应用中有很多的应用。那么掌握其遍历的方式对实际生产以及了解源码都很有益。
2、遍历方式
二叉树的主要遍历方式有4种：先序、中序、后序以及层序遍历
首先，声明一下节点TreeNode类，如下：
package com.kunkun.offer.show.common;
/**
* @author: liukun
* @Date: 2021/11/21
*/
public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
public TreeNode(int x) { val = x; }
}
2.1、先序遍历
先序遍历的遍历顺序：根 、左、右。
也就是说前序遍历就是先访问根节点，再访问左节点，最后访问右节点。
例：如图
image
我们按照先序遍历的访问顺序遍历这个二叉树得到的结果：3、9、20、15、7
在实际应用中，先序遍历主要有两种实现方式：递归和栈
具体实现：java
- 首先是递归的实现，递归的实现其实很简单。递归出口是当前节点是null的话，结束递归。先访问当前节点，依次访问左右节点就好了。
/**
* 先序遍历:根左右
*
* 递归
* @param root
*/
public void preTraversal(TreeNode root){
//递归出口
if(null == root) {
return;
}
System.out.println(root.val);
preTraversal(root.left);
preTraversal(root.right);
}
- 栈的先序遍历实现
/**
* 先序遍历
*
* 栈
* @param root
*/
public void preTraversal2(TreeNode root){
//递归出口
if(null == root) {
return;
}
//初始化栈
Stack stack = new Stack<>();
TreeNode p = root;
//如果p不为空，栈非空。进入循环
while (null != p || !stack.isEmpty()){
if (p != null) {
System.out.println(p.val);
stack.push(p);
p = p.left;
} else {
p = stack.pop();
p = p.right;
}
}
}
2.2、中序遍历
中序遍历的遍历顺序：左、根、右。
也就是说前序遍历就是先访问左子树，再访问根节点，最后访问右节点。
同样是上面那棵树，他的中序遍历是：9、3、15、20、7
具体实现：java
- 递归实现
/**
* 中序便利的递归实现：左根右
*
* @param root
*/
public void inTraversal(TreeNode root) {
if (null == root) {
return;
}
inTraversal(root.left);
System.out.println(root.val);
inTraversal(root.right);
}
- 栈实现
/**
* 中序遍历的栈实现
* @param root
*/
public void inTraversal2(TreeNode root) {
if (null == root) {
return;
}
Stack stack = new Stack<>();
TreeNode p = root;
//循环条件
while(null != p || !stack.isEmpty()){
if (p != null) {
stack.push(p);
p = p.left;
} else {
p = stack.pop();
System.out.println(p.val);
p = p.right;
}
}
}
2.3、后序遍历
中序遍历的遍历顺序：左、右、根。
也就是说前序遍历就是先访问左子树，再访问右节点，最后访问根节点。
同样是上面那棵树，他的中序遍历是：9、15、7、20、3
具体实现：java
- 递归实现
/**
* 二叉树后序遍历的递归实现：左右根
*
* @param root
*/
public void postorderTraversal(TreeNode root){
if (null == root) {
return;
}
postorderTraversal(root.left);
postorderTraversal(root.right);
System.out.println(root.val);
}
- 栈实现(先序遍历的变种、很多人使用的方法)
- 个人认为遍历算法的核心，其实是节点访问的次序，用这种方法，其实思想依然是先序遍历的，并不是真正后序遍历。
/**
* 后序遍历栈实现:
*
* 失去遍历算法核心的实现方法
* @param root
*/
public void postorderTraversal2(TreeNode root){
if (null == root) {
return;
}
Stack stack = new Stack<>();
List list = new LinkedList<>();
TreeNode p = root;
while(null != p || !stack.isEmpty()) {
if (null != p) {
list.add(p.val);
stack.push(p);
p = p.right;
}else {
p = stack.pop();
p = p.left;
}
}
Collections.reverse(list);
}
- 栈实现（重要）
/**
* 真正的后序遍历的栈实现
*
* 遍历算法的核心是内存的读取顺序
*
* 要熟练掌握这种方式
*
* @param root
*/
public void postorderTraversal3(TreeNode root){
if (null == root) {
return;
}
Stack stack = new Stack<>();
TreeNode p = root;
TreeNode prev = null;
List result = new LinkedList<>();
while (null != p || !stack.isEmpty()) {
while(p != null){
stack.push(p);
p = p.left;
}
p = stack.pop();
if (null == p.right || prev == p.right) {
result.add(p.val);
prev = p;
p = null;
} else {
stack.push(p);
p = p.right;
}
}
}
2.4、层序遍历
层序遍历是将二叉树每一层从左到右访问
接上面的例子，访问顺序为：3、9、20、15、7
具体实现：java
- 队列的方式
/**
* 二叉树的层序遍历
*
* @param root
* @return
*/
public static List levelOrder(TreeNode root) {
if (null == root) {
return new LinkedList<>();
}
List queue = new LinkedList<>();
TreeNode p = root;
queue.add(p);
List result = new LinkedList<>();
while(queue.size() != 0){
p = queue.remove(0);
result.add(p.val);
if (p.left != null) {
queue.add(p.left);
}
if (p.right != null) {
queue.add(p.right);
}
}
return result;
}
3、总结
二叉树的遍历是数据结构中非常重要的一章，先序、中序、后序对应的递归和栈的实现方式需要熟练掌握。尤其后续的栈实现，比较复杂。