二叉树的层序遍历经典问题（算法村第六关白银挑战）

基本的层序遍历与变换

二叉树的层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

解

public static List<List<Integer>> levelOrder(TreeNode root)
{
    //特判，否则queue.offer(root)会抛出NullPointerException
    if (root == null)
        return new ArrayList<List<Integer>>();

    ArrayList<List<Integer>> ans = new ArrayList<>();

    ArrayDeque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);

    while (!queue.isEmpty())
    {
       //获取当前层的结点个数
       int size = queue.size();
            
       //该层结点的值
       ArrayList<Integer> list = new ArrayList<>();

        //遍历当前层
        for (int i = 0; i< size; i++)
        {
            TreeNode t = queue.remove();
            list.add(t.val);

            if (t.left != null)
                queue.offer(t.left);
            if (t.right != null)
                queue.offer(t.right);
        }

        //将这一层结点的值加入答案
        ans.add(list);
    }

    return ans;
}

自底而上的层序遍历

107. 二叉树的层序遍历 II - 力扣（LeetCode）

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

解

在遍历完一层节点之后，将存储该层节点值的列表 list 添加到结果列表 ans 的头部即可。

为了时间复杂度，ans 使用链式结构的结构。在 ans 头部添加一层节点值的列表 list 的时间复杂度是 O(1)

public List<List<Integer>> levelOrderBottom(TreeNode root)
{
    //特判，否则queue.offer(root)会抛出NullPointerException
    if (root == null)
        return new ArrayList<List<Integer>>();

    ArrayList<List<Integer>> ans = new ArrayList<>();

    ArrayDeque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);

    while (!queue.isEmpty())
    {
        //获取当前层的结点个数
        int size = queue.size();

        //该层结点的值
        ArrayList<Integer> list = new ArrayList<>();

        //遍历当前层
        for (int i = 0; i< size; i++)
        {
            TreeNode t = queue.remove();
            list.add(t.val);

            if (t.left != null)
                queue.offer(t.left);
            if (t.right != null)
                queue.offer(t.right);
        }

        //将这一层结点的值插入答案的头部
        ans.add(0,list);
    }

    return ans;
}

锯齿形层序遍历

103. 二叉树的锯齿形层序遍历 - 力扣（LeetCode）

给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]

用双端队列维护当前层节点的存储

双端队列可以队头或队尾插入元素。

层序遍历顺序不变，但对当前层节点的存储，我们维护一个变量 isOrderLeft ，记录结点存储是从左至右还是从右至左

若从左至右，则采用头插法。该层第一个元素在此层遍历结束后，会出现在list的末端
若从右至左，则采用尾插法。该层第一个元素在此层遍历结束后，会出现在list的首端

最后需要注意的是，往 ans 添加 list 时，需要转换一下 list 的类型

public List<List<Integer>> zigzagLevelOrder(TreeNode root)
    {
        //特判，否则queue.offer(root)会抛出NullPointerException
        if (root == null)
            return new ArrayList<List<Integer>>();

        ArrayList<List<Integer>> ans = new ArrayList<>();

        ArrayDeque<TreeNode> queue = new ArrayDeque<>();
        queue.offer(root);

        boolean isOrderLeft = true;

        while (!queue.isEmpty())
        {
            //获取当前层的结点个数
            int size = queue.size();

            //该层结点的值。用一个双端队列存储
            ArrayDeque<Integer> deque = new ArrayDeque<>();

            //遍历当前层
            for (int i = 0; i< size; i++)
            {
                TreeNode t = queue.remove();

                if (isOrderLeft)
                    deque.offerLast(t.val);
                else
                    deque.offerFirst(t.val);

                if (t.left != null)
                    queue.offer(t.left);
                if (t.right != null)
                    queue.offer(t.right);
            }

            //这一层结点的值经过转换后加入答案
            ans.add(new LinkedList<>(deque));

            isOrderLeft = !isOrderLeft; //交替进行
        }

        return ans;
    }

N叉树的层序遍历

429. N 叉树的层序遍历 - 力扣（LeetCode）

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

结点类型

public class Node
{
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
}

解

public List<List<Integer>> levelOrder(Node root)
{
    //特判，否则queue.offer(root)会抛出NullPointerException
    if (root == null)
        return new ArrayList<List<Integer>>();

    ArrayList<List<Integer>> ans = new ArrayList<>();

    ArrayDeque<Node> queue = new ArrayDeque<>();
    queue.offer(root);

    while (!queue.isEmpty())
    {
        //获取当前层的结点个数
        int size = queue.size();

        //该层结点的值
        ArrayList<Integer> list = new ArrayList<>();

        //遍历当前层
        for (int i = 0; i< size; i++)
        {
            Node t = queue.remove();
            list.add(t.val);

            //将当前结点的所有孩子加入队列
            for (Node child : t.children)
            {
                queue.offer(child);
            }
        }

        //将这一层结点的值加入答案
        ans.add(list);
    }

    return ans;
}

处理每层元素

在每个树行中找最大值

515. 在每个树行中找最大值 - 力扣（LeetCode）

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

维护每层的最大值即可

public List<Integer> largestValues(TreeNode root)
{
    //特判，否则queue.offer(root)会抛出NullPointerException
    if (root == null)
        return new ArrayList<>();

    //存储每层结点的最大值
    ArrayList<Integer> list = new ArrayList<>();

    ArrayDeque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);

    while (!queue.isEmpty())
    {
        //获取当前层的结点个数
        int size = queue.size();

        //当前层结点的最大值
        int maxOfLevel = Integer.MIN_VALUE;

        //遍历当前层
        for (int i = 0; i< size; i++)
        {
            TreeNode t = queue.remove();

            maxOfLevel = Math.max(maxOfLevel, t.val);

            if (t.left != null)
                queue.offer(t.left);
            if (t.right != null)
                queue.offer(t.right);
        }

        list.add(maxOfLevel);
    }

    return list;
}

二叉树的层平均值

637. 二叉树的层平均值 - 力扣（LeetCode）

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

解

public List<Double> averageOfLevels(TreeNode root)
{
    //特判，否则queue.offer(root)会抛出NullPointerException
    if (root == null)
        return new ArrayList<>();

    //存储每层结点的最大值
    ArrayList<Double> list = new ArrayList<>();

    ArrayDeque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);

    while (!queue.isEmpty())
    {
        //获取当前层的结点个数
        int size = queue.size();

        //当前层结点值的和
        double sum = 0;

        //遍历当前层
        for (int i = 0; i< size; i++)
        {
            TreeNode t = queue.remove();

            sum += t.val;

            if (t.left != null)
                queue.offer(t.left);
            if (t.right != null)
                queue.offer(t.right);
        }
		
        //计算平均值并添加到列表
        list.add(sum / size);
    }

    return list;
}

二叉树的右视图

199. 二叉树的右视图 - 力扣（LeetCode）

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

解

层序遍历，记录每层最后一个元素即可

public List<Integer> rightSideView(TreeNode root)
{
    //特判，否则queue.offer(root)会抛出NullPointerException
    if (root == null)
        return new ArrayList<>();

    //存储每层的最后一个结点
    ArrayList<Integer> list = new ArrayList<>();

    ArrayDeque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);

    while (!queue.isEmpty())
    {
        //获取当前层的结点个数
        int size = queue.size();

        //遍历当前层
        for (int i = 0; i < size; i++)
        {
            TreeNode t = queue.remove();

            //记录当前层最后一个元素
            if (i == size - 1)
                list.add(t.val);

            if (t.left != null)
                queue.offer(t.left);
            if (t.right != null)
                queue.offer(t.right);
        }
    }

    return list;
}

最底层最左边的结点

513. 找树左下角的值 - 力扣（LeetCode）

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

从右往左层序遍历

从右向左层次遍历，最后一个访问的节点必然是最底层最左侧叶子节点。只需调整一下左右孩子加入队列的次序即可

public int findBottomLeftValue(TreeNode root)
{
    ArrayDeque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);

    TreeNode t = null;

    while (!queue.isEmpty())
    {
        //获取当前层的结点个数
        int size = queue.size();

        //遍历当前层
        for (int i = 0; i < size; i++)
        {
            t = queue.remove();

            //右孩子先于左孩子放入队列
            if (t.right != null)
                queue.offer(t.right);
            if (t.left != null)
                queue.offer(t.left);
        }
    }

    return t.val;   //返回最底层最右边的结点的值
}

左叶子之和

404. 左叶子之和 - 力扣（LeetCode）

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

提示:

节点数在 [1, 1000] 范围内

广度优先遍历

在BFS的过程中添加一个判断是否为左叶子结点的条件语句即可

public int sumOfLeftLeaves(TreeNode root)
{
    int answer = 0;

    ArrayDeque<TreeNode> queue = new ArrayDeque<>();
    queue.offer(root);


    while (!queue.isEmpty())
    {
        //获取当前层的结点个数
        int size = queue.size();

        //遍历当前层
        for (int i = 0; i < size; i++)
        {
            TreeNode t = queue.remove();

            if (t.left != null)
            {
                //如果t的左孩子是叶子结点
                if(t.left.left == null && t.left.right == null)
                    answer += t.left.val;
                else
                    queue.offer(t.left);
            }
            if (t.right != null)
                queue.offer(t.right);

        }
    }

    return answer;
}