二叉树遍历
二叉树遍历分为三种，前序遍历，中序遍历 以及 后续遍历。三种的区别在于遍历中间结点的顺序：
- 前序遍历：中间节点，左节点，右节点
- 中序遍历：左节点，中间节点，右节点
- 后续遍历：左节点，右节点，中间节点
遍历二叉树有三种主要的方法：
- 递归法
- 迭代法
- 层序遍历
递归遍历
递归法有三个要点：
- 递归参数以及返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
- 确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
- 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程
对于遍历二叉树，我们的递归三要素为：
- 参数和返回值：参数为
root和List, 因为有了根节点我们就能打印出整个二叉树；返回值为void，因为root和List都为引用类型，因此不需要返回。这里传入参数我们也可以定义为全局变量，因此传入参数也可以不需要List。
void traversal(TreeNode root);
- 终止条件：当当前遍历节点为空时，本层的递归就应该结束了。
if (root == null) return;
- 确定单层递归的逻辑： 以前序遍历为例，因为遍历顺序为 中 左 右，因此首先处理中间节点，然后递归左右节点。
list.add(root.val);
traversal(root.left);
traversal(root.right);
代码实现
前序遍历：
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
preorder(root, result);
return result;
}
public void preorder(TreeNode root, List<Integer> result) {
if (root == null) {
return;
}
result.add(root.val);
preorder(root.left, result);
preorder(root.right, result);
}
}
中序遍历：
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
inorder(root, res);
return res;
}
void inorder(TreeNode root, List<Integer> list) {
if (root == null) {
return;
}
inorder(root.left, list);
list.add(root.val);
inorder(root.right, list);
}
}
后序遍历：
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
inorder(root, res);
return res;
}
void inorder(TreeNode root, List<Integer> list) {
if (root == null) {
return;
}
inorder(root.left, list);
list.add(root.val);
inorder(root.right, list);
}
}
迭代遍历：统一迭代遍历
统一迭代遍历是指使用统一风格的代码来完成 前 中 后 序三种不同顺序的遍历。
思路和递归一样，只不过实现方法不同。在迭代法中，我们使用栈来实现遍历。
这里先贴上前序遍历的代码实现。
代码实现-前序遍历：
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new LinkedList<>();
Stack<TreeNode> st = new Stack<>();
if (root != null) st.push(root);
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
st.pop();
result.add(node.val); // 加入到结果集
}
}
return result;
}
}
可以看到以上代码，我们可以将每一次 while 循环想象成一次递归，在每层循环中我们都是先处理中间节点，然后左节点，最后右节点（前序遍历）。
统一迭代法本质上就是模拟 Java 虚拟机对递归的调用。
代码实现
中序遍历：
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new LinkedList<>();
Stack<TreeNode> st = new Stack<>();
if (root != null) st.push(root);
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
st.pop();
result.add(node.val); // 加入到结果集
}
}
return result;
}
}
后序遍历：
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new LinkedList<>();
Stack<TreeNode> st = new Stack<>();
if (root != null) st.push(root);
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
st.pop();
result.add(node.val); // 加入到结果集
}
}
return result;
}
}
