leetcode102.层序遍历（DFS）

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        List<TreeNode> TreeArr = new ArrayList<>();
        Deque<TreeNode> st = new LinkedList<>();
        if(root == null) return res;
        st.addLast(root);
        while(true) {
            List<Integer> arr = new ArrayList<>();
            //arr里存放上一层的值，TreeArr存放下一层的节点
            while(!st.isEmpty()){
                TreeNode cur = st.pollFirst();
                arr.add(cur.val);
                if(cur.left != null) TreeArr.add(cur.left);
                if(cur.right != null) TreeArr.add(cur.right);
            }
            res.add(arr);
            //如果下一层没有节点了，就break
            if(TreeArr.size() == 0) break;
            //把TreeArr里的节点赋值到队列st中继续循环
            for(TreeNode i:TreeArr){
                st.addLast(i);
            }
            TreeArr.clear();            
        }
        return res;
    }
}

这个版本需要把每一层的节点存到TreeArr中，再赋值给st队列，消耗了空间，来个改进版

迭代法：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        Queue<TreeNode> que = new LinkedList<>();
        if(root == null) return res;
        que.offer(root);
        int len;
        while(!que.isEmpty()) {
            List<Integer> arr = new ArrayList<>();
            //len记录这一层的长度并提取出来，que中加入下一层的节点，但是由于len和que.size()独立，所以可以实现分层
            len = que.size();
            while(len > 0){
                TreeNode cur =que.poll();
                arr.add(cur.val);
                if(cur.left != null) que.offer(cur.left);
                if(cur.right != null) que.offer(cur.right);
                len--;
            }
            res.add(arr);        
        }
        return res;
    }
}

再上一个递归法的，来自代码随想录Carl

class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        //checkFun01(root,0);
        checkFun02(root);

        return resList;
    }

    //DFS--递归方式
    public void checkFun01(TreeNode node, Integer deep) {
        if (node == null) return;
        deep++;

        if (resList.size() < deep) {
            //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
            List<Integer> item = new ArrayList<Integer>();
            resList.add(item);
        }
        resList.get(deep - 1).add(node.val);

        checkFun01(node.left, deep);
        checkFun01(node.right, deep);
    }
}

用二叉树遍历的迭代法中，deep标记深度，按照左右顺序添加node，perfect！