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

基本的层序遍历与变换

二叉树的层序遍历

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)会抛出NullPointerExceptionif (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)会抛出NullPointerExceptionif (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)会抛出NullPointerExceptionif (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);elsedeque.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)会抛出NullPointerExceptionif (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)会抛出NullPointerExceptionif (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)会抛出NullPointerExceptionif (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)会抛出NullPointerExceptionif (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;elsequeue.offer(t.left);}if (t.right != null)queue.offer(t.right);}}return answer;
}