二叉树的遍历（递归+迭代）
总结一下二叉树的四种遍历方式，用递归和迭代，递归代码比较简单，迭代代码相对比较复杂点。
二叉树的遍历
- 一.前序遍历
-
- 思路
- 代码
-
- 递归
- 迭代
- 二.中序遍历
-
- 思路
- 代码
-
- 递归
- 迭代
- 三.后序遍历
-
- 思路
- 代码
-
- 递归
- 迭代
- 四.层序遍历
-
- 思路
- 代码
-
- 递归
- 迭代
一.前序遍历
（这里以打印出结果为例，还可以用ArrayList，存储子树中的val）
思路
递归：先根节点，再左子树，再右子树。
迭代：需要使用到栈。先压栈root，进入循环（结束循环条件为：栈空），再弹栈用top保留下来打印val，判断top右子树不为空，则压栈，判断top左子树不为空，也压栈（这两个判断顺序不能改变）。拿图直观理解一下。
代码
递归
public static void preOrder(Node root){
//根节点为空，直接结束
if(root==null){
return;
}
//根节点
System.out.print(root.val+" ");
//左子树
preOrder(root.left);
//右子树
preOrder(root.right);
}
迭代
public static void preOrder(TreeNode root){
//根节点为空，直接结束
if(root==null){
return;
}
Stack<TreeNode> s=new Stack<>();
//先入栈
s.push(root);
while (!s.empty()){
TreeNode top=s.pop();
System.out.print(top.val+" ");
//先右后左，顺序不能乱
if(top.right!=null){
s.push(top.right);
}
if(top.left!=null){
s.push(top.left);
}
}
}
二.中序遍历
思路
递归：先根左子树，再根节点，再右子树。
迭代：cur=root，进入一个死循环（里面有if判断条件，栈空，则break）;
1.再进入一个循环，cur不为空，则入栈，一直向左，入栈,直到左子树为空。
2.判断if，栈空则结束死循环。
3.弹栈，打印。
4.cur=top.right。
重复上述操作
代码
递归
public static void inOrder(Node root){
//根节点为空，直接结束
if(root==null){
return;
}
//左子树
inOrder(root.left);
//根节点
System.out.print(root.val+" ");
//右子树
inOrder(root.right);
}
迭代
public static void inOrder(TreeNode root){
//根节点为空，直接结束
if(root==null){
return;
}
Stack<TreeNode> s=new Stack<>();
TreeNode cur=root;
while (true){
//往左找，并且入栈
while (cur!=null){
s.push(cur);
cur=cur.left;
}
//栈为空，遍历就结束
if(s.empty()){
break;
}
//取栈顶元素访问
TreeNode top=s.pop();
System.out.print(top.val+" ");
//从当前节点右子树出发重复上面操作
cur=top.right;
}
}
三.后序遍历
思路
递归：先根左子树，再根右子树，再根节点。
迭代：后序的思路和中序差不多，有一点区别在于，
取栈顶元素的时候此时是peek（），要看栈顶元素，是否有右子树或者右子树是否已经被访问过了。当没有右子树，或者已经访问过，则直接弹栈打印。
其余操作和中序一样，看代码就可以理解。
代码
递归
public static void postOrder(Node root){
//根节点为空，直接结束
if(root==null){
return;
}
//左子树
postOrder(root.left);
//右子树
postOrder(root.right);
//根节点
System.out.print(root.val+" ");
}
迭代
public static void postOrder(TreeNode root){
//根节点为空，直接结束
if(root==null){
return;
}
Stack<TreeNode> s=new Stack<>();
TreeNode cur=root;
TreeNode prev=null;
while (true){
//往左找，并且入栈
while (cur!=null){
s.push(cur);
cur=cur.left;
}
//栈为空，遍历就结束
if(s.empty()){
break;
}
//取出栈顶元素来看看能不能访问
TreeNode top=s.peek();
//栈顶元素右子树为空，或者已经被访问过了
if(top.right==null||top.right==prev){
System.out.println(top.val+" ");
s.pop();
//保持好，prve为已经遍历完的最后一个元素（这个细节很重要哦）用来判断是否已经访问过了
prev=top;
}else {
cur=top.right;
}
}
}
四.层序遍历
思路
递归：以力扣的102题为例。
迭代：用队列来操作。先入队root，进入循环（结束条件，队列为空）。
1.cur保存出队元素，并打印val。
2.cur.left不为空，则入队。
3.cur.right 不为空，则入队。
重新操作循环。直到队列为空，结束循环。
代码
递归
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result=new ArrayList<>();
//根节点为空，直接结束
if(root==null){
return result;
}
helper(root,0,result);
return result;
}
private void helper(TreeNode root, int level,List<List<Integer>> result) {
//当访问的该行没有在result中对应的时候，就加入一行
if(level==result.size()){
result.add(new ArrayList<>());
}
//get访问到行，add添加元素val
result.get(level).add(root.val);
//访问左边
if(root.left!=null){
helper(root.left,level+1,result);
}
//访问右边
if(root.right!=null){
helper(root.right,level+1,result);
}
}
迭代
public static void levelOrder(Node root){
//根节点为空，直接结束
if(root==null){
return;
}
Queue<Node> queue=new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()){
Node cur=queue.poll();
System.out.print(cur.val+" ");
//判断左子树
if(cur.left!=null){
queue.offer(cur.left);
}
//判断右子树
if(cur.right!=null){
queue.offer(cur.right);
}
}
}