二叉树专题（1）--递归在手，说走就走

做二叉树的题，不用递归，简直是耍流氓—鲁迅

二叉树专题一：遍历节点

我认为啊，递归的思想其实很简单，你不用琢磨函数到底发生了什么，你只要认为，这个函数就是干这个功能的就行了，参数放进这个函数中就能发生你想要的变化

1、 前序遍历

题目来源：
leetcode 144. 二叉树的前序遍历 https://leetcode.cn/problems/binary-tree-preorder-traversal/
思想：递归
你想这种前序中序后序遍历啊，其实都算是DFS，可以用栈来实现（递归本身就是利用栈的特性），但是递归吧，它简洁啊，而且二叉树用递归很香的，所以我们这里就光说递归如何实现遍历了
题解：
执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：39.4 MB, 在所有 Java 提交中击败了94.81% 的用户
通过测试用例：69 / 69

import java.util.*;
class Solution {
    List<Integer> list = new ArrayList<Integer>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null){
            return list;
        }
        //遍历自己
        list.add(root.val);
        //遍历左子树
        preorderTraversal(root.left);
        //遍历右子树
        preorderTraversal(root.right);
        //遍历全树之后返回list
        return list;
    }
}

2、中序遍历

题目来源：
leetcode 94. 二叉树的中序遍历 https://leetcode.cn/problems/binary-tree-inorder-traversal/
思想：递归
其实就是遍历顺序换个个儿
题解：
执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：39.5 MB, 在所有 Java 提交中击败了78.10% 的用户
通过测试用例：70 / 70

import java.util.*;
class Solution {
    List<Integer> list = new ArrayList<Integer>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root == null){
            return list;
        }
        inorderTraversal(root.left);
        list.add(root.val);
        inorderTraversal(root.right);
        return list;
    }
}

3、后序遍历

题目来源：
leetcode 145. 二叉树的后序遍历 https://leetcode.cn/problems/binary-tree-postorder-traversal/
思想：递归
其实就是遍历顺序换个个儿
题解：
执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：39.3 MB, 在所有 Java 提交中击败了95.54% 的用户
通过测试用例：68 / 68

import java.util.*;
class Solution {
    List list = new ArrayList();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root == null){
            return list;
        }
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        list.add(root.val);
        return list;
    }
}

4、层序遍历

题目来源：
leetcode 102. 二叉树的层序遍历 https://leetcode.cn/problems/binary-tree-level-order-traversal/
思想：递归
这个吧，其实队列也是可以滴，栈前后中序，队列层序，但是不用递归的话显得代码太臃肿，所以这里我们用递归来实现下
题解：
执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
内存消耗：41.3 MB, 在所有 Java 提交中击败了91.85% 的用户
通过测试用例：34 / 34

import java.util.*;
class Solution {
    //这个集合中放的元素是集合，集合的个数为有多少层
   List<List<Integer>> levels = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        level(root,0);
        return levels;
    }

    //这个方法是层序遍历哪棵树，从哪一层开始遍历
    public void level(TreeNode root,int level){
        if(root == null){
            return ;
        }

        if(level >= levels.size()){
            levels.add(new ArrayList<Integer>());
        }

        //先遍历自己
        levels.get(level).add(root.val);
        //遍历左树右树
        level(root.left,level + 1);
        level(root.right,level + 1);

    }
}

其实我最开始也是照猫画虎和别人学过来的
我是这样理解的，对于大多数的树问题，都需要考虑到根节点和左右节点。这个level方法呢，参数是一个TreeNode，一个level。
这两个参数什么意思呢，就是说，root代表一颗树，你把树放进这个方法中，它就可以开始层序遍历了，level是目前从哪一层开始遍历，你都把root放进来了，你肯定得告诉人家从第012345…层开始遍历吧，所以说其实不一定level要从0开始，你要从第6层遍历，level还是6了，对吧。下面的一new ArrayList（）就是说（先明白一个概念，List中的List才是层数，List中有几个List就有几个层数）如果你现在层数小于人家起始遍历的层数，你得给人家补上。下面的代码更没啥说的了，先找到自己的层数，然后遍历自己，再遍历左子树，右子树。

唉，力扣还是要早刷啊兄弟们，大一光浪了，导致我是最近一个多礼拜才开始玩起来这个LeetCode，难受啊，等我再玩几天破100！