二叉树的层序遍历
由于二叉树的特性,每个节点既可以作为其上层节点的孩子节点,也可以作为下层节点的父节点,所以与深度优先遍历一样,层序遍历可以使用递归法来实现。
同时,因为二叉树可以使用栈来进行深度优先的迭代遍历,那么作为广度优先的层序遍历,也可以使用队列来进行广度优先的迭代遍历。
二叉树的层序遍历思路也较为清晰明了,跟着代码过一遍即容易理解,同时利用二叉树层序遍历的题目,也能够轻松解决,因为此类题目的本质都是一样的,只需替换逻辑操作的模块即可。
Leetcode题目-102. Binary Tree Level Order Traversal
链接: 102. Binary Tree Level Order Traversal
代码实现
1. 递归法
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
leverOrderRec(root, 0, result);
return result;
}
public void leverOrderRec(TreeNode root, int depth, List<List<Integer>> result) {
if (root == null) {
return;
}
if (result.size() == depth) {
result.add(new ArrayList<>());
}
result.get(depth).add(root.val);
leverOrderRec(root.left, depth + 1, result);
leverOrderRec(root.right, depth + 1, result);
}
}
2. 迭代法
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
List<Integer> levelList = new ArrayList<>();
for (int i = 0; i < len; i++) {
TreeNode node = queue.poll();
levelList.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
result.add(levelList);
}
return result;
}
}
层序遍历模版
分析一下上面的迭代法代码,可以比较容易理解思路。与层序遍历有关的题目,通常的变换是对二叉树的操作,计算的结果不同,在此类题目中,我们可以通过变更上述代码中的一些逻辑操作来实现,几乎等同于“套模版”的答题法。
模版可以参考以下代码:
class Solution {
public ? levelOrder(TreeNode root) {
// 根据题目要求初始化返回值等操作
// ? result = new ?();
Queue<TreeNode> queue = new ArrayDeque<>();
if (root == null) {
// 空情况处理
}
queue.offer(root);
while (!queue.isEmpty()) {
int len = queue.size();
for (int i = 0; i < len; i++) {
/*
进行一些题目要求的逻辑操作
*/
// 把遍历完的节点的左右子节点插入
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
/*
进行一些题目要求的逻辑操作
*/
}
// 返回值
return result;
}
}
相关题目&解答代码
107.二叉树的层次遍历II
链接: 107. Binary Tree Level Order Traversal II
class Solution {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> result = new ArrayList<>();
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
List<Integer> levelList = new ArrayList<>();
for (int i = 0; i < len; i++) {
TreeNode node = queue.poll();
levelList.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
result.add(0, levelList);
}
return result;
}
}
199.二叉树的右视图
链接: 199. Binary Tree Right Side View
class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> result = new ArrayList<>();
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
TreeNode node = new TreeNode();
for (int i = 0; i < len; i++) {
node = queue.poll();
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
result.add(node.val);
}
return result;
}
}
637.二叉树的层平均值
链接: 637. Average of Levels in Binary Tree
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
List<Double> result = new ArrayList<>();
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
TreeNode node = new TreeNode();
double sum = 0;
for (int i = 0; i < len; i++) {
node = queue.poll();
sum += node.val;
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
result.add(sum / len);
}
return result;
}
}
429.N叉树的层序遍历
链接: 429. N-ary Tree Level Order Traversal
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> result = new ArrayList<>();
Queue<Node> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
List<Integer> levelResult = new ArrayList<>();
for (int i = 0; i < len; i++) {
Node node = queue.poll();
levelResult.add(node.val);
for (Node children : node.children) {
queue.offer(children);
}
}
result.add(levelResult);
}
return result;
}
}
515.在每个树行中找最大值
链接: 515. Find Largest Value in Each Tree Row
class Solution {
public List<Integer> largestValues(TreeNode root) {
List<Integer> result = new ArrayList<>();
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
int levelMax = Integer.MIN_VALUE;
for (int i = 0; i < len; i++) {
TreeNode node = queue.poll();
if (node.val > levelMax) {
levelMax = node.val;
}
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
result.add(levelMax);
}
return result;
}
}
116.填充每个节点的下一个右侧节点指针
链接: 116. Populating Next Right Pointers in Each Node
class Solution {
public Node connect(Node root) {
Queue<Node> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
Node cur = null;
for (int i = 0; i < len; i++) {
if (i == 0) {
cur = queue.poll();
}else {
cur.next = queue.poll();
cur = cur.next;
}
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
cur.next = null;
}
return root;
}
}
117.填充每个节点的下一个右侧节点指针II
链接: 117. Populating Next Right Pointers in Each Node II
class Solution {
public Node connect(Node root) {
Queue<Node> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int len = queue.size();
Node cur = null;
for (int i = 0; i < len; i++) {
if (i == 0) {
cur = queue.poll();
} else {
cur.next = queue.poll();
cur = cur.next;
}
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
cur.next = null;
}
return root;
}
}
104.二叉树的最大深度
链接: 104. Maximum Depth of Binary Tree
class Solution {
public int maxDepth(TreeNode root) {
int maxDepth = 0;
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int size = queue.size();
for (int i = 0; i < size; i++) {
TreeNode node = queue.poll();
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
maxDepth++;
}
return maxDepth;
}
}
111.二叉树的最小深度
链接: 1111. Minimum Depth of Binary Tree
class Solution {
public int minDepth(TreeNode root) {
int minDepth = 0;
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int size = queue.size();
minDepth++;
for (int i = 0; i < size; i++) {
TreeNode node = queue.poll();
if (node.left == null && node.right == null) {
return minDepth;
}
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
return minDepth;
}
}
翻转二叉树
Leetcode题目-226. Invert Binary Tree
思路
翻转二叉树是指整个树以中间分割线进行翻转,其实就是将节点的左右子树互换。结合之前对二叉树遍历的了解,可以得出我们边遍历边互换就可以了,但是需要注意,要明确自己所用的遍历方法的原理,这样才能明白,左右子树互换的操作要在何时进行。例如在中序遍历中,如果采用迭代遍历,节点有可能会被两次访问,从而造成两次互换。此种情况下,选择前序遍历/后序遍历、层序遍历、统一迭代遍历(前中后序皆可)都是比较合适的。递归作为二叉树题目的重要解法,也适用。
代码实现
1. 递归法
递归法的书写过程中,依旧遵照并注意三个要点:递归函数的确定(入参,返回值),递归终止条件的确定,单层递归的逻辑。
class Solution {
public TreeNode invertTree(TreeNode root) {
swapLeftAndRight(root);
return root;
}
public TreeNode swapLeftAndRight(TreeNode root) {
if (root==null) {
return null;
}
TreeNode node = root.left;
root.left = swapLeftAndRight(root.right);
root.right = swapLeftAndRight(node);
return root;
}
}
2. 迭代法
class Solution {
public TreeNode invertTree(TreeNode root) {
// 迭代法:前序遍历
Deque<TreeNode> stack = new ArrayDeque<>();
if (root != null) {
stack.push(root);
}
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
TreeNode tmp = node.left;
node.left = node.right;
node.right = tmp;
if (node.left != null) {
stack.push(node.left);
}
if (node.right != null) {
stack.push(node.right);
}
}
return root;
}
}
class Solution {
public TreeNode invertTree(TreeNode root) {
// 统一迭代法:前序遍历
Deque<TreeNode> stack = new LinkedList<>();
if (root != null) {
stack.push(root);
}
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
if (node != null) {
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
stack.push(node);
stack.push(null);
} else {
node = stack.pop();
TreeNode tmp = node.left;
node.left = node.right;
node.right = tmp;
}
}
return root;
}
}
class Solution {
public TreeNode invertTree(TreeNode root) {
// 层序遍历
Queue<TreeNode> queue = new ArrayDeque<>();
if (root != null) {
queue.offer(root);
}
while (!queue.isEmpty()) {
int levelSize = queue.size();
for (int i = 0; i < levelSize; i++) {
TreeNode node = queue.poll();
TreeNode tmp = node.left;
node.left = node.right;
node.right = tmp;
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
return root;
}
}
对称二叉树
Leetcode题目-226. Invert Binary Tree
思路
对称二叉树,需要弄明白的是我们如何判断比较左右子树,从而判断它是不是一个对称二叉树。如图可看出,它并不是节点的左右子树相等,而是左右节点的外侧节点和内侧节点相等。同样此题也可以使用迭代和递归两种方法来求解。
代码实现
1. 递归法
递归法的三个步骤:
-
递归的函数(入参、出参):输入父节点的左右两个子树,比较两个子树的内外侧,返回一个比较结果bool值
-
递归结束的条件:这里有多种情况,主要与左右子节点是否为空和是否符合对称有关,如下:
- 左右节点都为空:父节点为叶子结点,父节点对称,返回true;
- 左节点为空而右节点不为空或左节点不为空而右节点为空:此时父节点肯定不对称,返回false;
- 左右节点均不为空,但是左右节点值不相同,那么也不对称,返回false;
-
单层递归的逻辑:除了上述需要结束的条件,剩下可能对称需要继续判断的情况就是:左右节点均不为空且左右节点值相同;此时进行递归,逻辑就是,比较左右子树的外侧和内侧是否相等,只要有一侧结果不相等,则对称不成立。
class Solution {
public boolean isSymmetric(TreeNode root) {
if (root == null) {
return true;
}
return compare(root.left, root.right);
}
public boolean compare(TreeNode left, TreeNode right) {
if (left == null && right == null) {
return true;
} else if (left != null && right == null) {
return false;
} else if (left == null && right != null) {
return false;
} else if (left.val != right.val) {
return false;
}
return compare(left.left, right.right) && compare(left.right, right.left);
}
}
2. 迭代法
迭代法中,主要的思路其实与递归法类似,但是这里用一个队列来暂存需要比较的两个节点,每次迭代中,从队列取出两个元素进行比较,并将其内外侧的孩子节点放入下一轮比较中,直到比较结束或提前中断。
class Solution {
public boolean isSymmetric(TreeNode root) {
if (root == null) {
return true;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root.left);
queue.offer(root.right);
while (!queue.isEmpty()) {
TreeNode left = queue.poll();
TreeNode right = queue.poll();
if (left == null && right == null) {
continue;
}
if (left == null || right == null || left.val != right.val) {
return false;
}
queue.offer(left.left);
queue.offer(right.right);
queue.offer(left.right);
queue.offer(right.left);
}
return true;
}
}