代码随想录-二叉树 | 层序遍历

LeetCode 102-二叉树的层序遍历

102-二叉树的层序遍历、107-二叉树的层序遍历II、199-二叉树的右视图、
637-二叉树的层平均值、429-N叉数的层序遍历、515-在每个树行中找最大值、116-填充每个节点的下一个右侧节点指针、117-填充每个节点的下一个右侧节点指针II、104-二叉树的最大深度、111-二叉树的最小深度

代码随想录

题目描述

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

解题思路

判断：

• 方法一：递归解法。模拟深度优先遍历，先进后出。
• 方法二：队列实现，使用辅助队列。模拟广度优先遍历，先进先出（符合一层一层遍历的逻辑）。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

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);
    }

    //BFS--迭代方式--借助队列
    public void checkFun02(TreeNode node){
        if(node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);

        while(!que.isEmpty()){
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();

            while(len > 0){
                TreeNode tmpNode = que.poll();
                itemList.add(tmpNode.val);

                if(tmpNode.left != null) que.offer(tmpNode.left);
                if(tmpNode.right != null) que.offer(tmpNode.right);
                len--;
            }
            resList.add(itemList);
        }
    }
}

难点

• 层级遍历的思路：这里每一层需要单独创建一个列表。有深度优先遍历和广度优先遍历两种解决方案，即递归和迭代。其中，递归的逻辑使用栈，后进后出。迭代的逻辑使用队列，先进先出。

总结

学习到新知识：广度优先遍历。其实，二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用。需要借助队列来实现（这也是队列的一个应用）。