LeetCode 101~105
2024-04-23 04:06:48
前言
本文隶属于专栏《LeetCode 刷题汇总》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！
本专栏目录结构请见LeetCode 刷题汇总
Github 配套工程
algorithm
正文
幕布
幕布链接
101. 对称二叉树
题解
官方题解
递归，两层
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode101.solution1;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;/*** 递归** @author Shockang*/
public class Solution {public boolean isSymmetric(TreeNode root) {return root == null || isSymmetric(root.left, root.right);}private boolean isSymmetric(TreeNode left, TreeNode right) {if (left == null || right == null) {return left == right;}if (left.val != right.val) {return false;}return isSymmetric(left.left, right.right) && isSymmetric(left.right, right.left);}}
迭代，栈，1 次弹出 2 个 压入 4 个
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode101.solution2;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.Deque;
import java.util.LinkedList;/*** @author Shockang*/
public class Solution {public boolean isSymmetric(TreeNode root) {if (root == null) {return true;}// ArrayDeque 不能 push nullDeque<TreeNode> stack = new LinkedList<>();stack.push(root.left);stack.push(root.right);while (!stack.isEmpty()) {TreeNode n1 = stack.pop(), n2 = stack.pop();if (n1 == null && n2 == null) {continue;}if (n1 == null || n2 == null || n1.val != n2.val) {return false;}stack.push(n1.left);stack.push(n2.right);stack.push(n1.right);stack.push(n2.left);}return true;}
}
102. 二叉树的层序遍历
题解
官方题解
递归，level
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode102.solution1;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.ArrayList;
import java.util.List;/*** 递归** @author Shockang*/
public class Solution {public List<List<Integer>> levelOrder(TreeNode root) {if (root == null) return new ArrayList<>(0);List<List<Integer>> res = new ArrayList<>();helper(root, res, 0);return res;}private void helper(TreeNode node, List<List<Integer>> list, int level) {if (node == null) return;if (level < list.size()) {List<Integer> tmp = list.get(level);tmp.add(node.val);} else {List<Integer> tmp = new ArrayList<>();tmp.add(node.val);list.add(tmp);}helper(node.left, list, level + 1);helper(node.right, list, level + 1);}
}
迭代，队列
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode102.solution2;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;/*** 迭代** @author Shockang*/
public class Solution {public List<List<Integer>> levelOrder(TreeNode root) {//返回的结果List<List<Integer>> res = new ArrayList<>();if (null == root) {return res;}Queue<TreeNode> queue = new LinkedList<>();//根节点入队queue.add(root);while (!queue.isEmpty()) {//一层的结果List<Integer> level = new ArrayList<>();int levelCount = queue.size();//添加节点到一层的List中去for (int i = 0; i < levelCount; i++) {//节点出队TreeNode node = queue.remove();//节点的左子树入队if (node.left != null) {queue.add(node.left);}//节点的右子树入队if (node.right != null) {queue.add(node.right);}level.add(node.val);}res.add(level);}return res;}
}
103. 二叉树的锯齿形层序遍历
题解
官方题解
递归，LinkedList
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode103.solution2;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;/*** 递归+LinkedList** @author Shockang*/
public class Solution {public List<List<Integer>> zigzagLevelOrder(TreeNode root) {List<List<Integer>> list = new ArrayList<>();helper(list, root, 0);return list;}private void helper(List<List<Integer>> list, TreeNode node, int level) {if (node == null) {return;}if (level < list.size()) {if (level % 2 == 0) {((LinkedList) list.get(level)).addLast(node.val);} else {((LinkedList) list.get(level)).addFirst(node.val);}} else {LinkedList<Integer> tmp = new LinkedList<>();tmp.add(node.val);list.add(tmp);}helper(list, node.left, level + 1);helper(list, node.right, level + 1);}
}
递归，add(0,)
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode103.solution1;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.ArrayList;
import java.util.List;/*** 递归+addList** @author Shockang*/
public class Solution {public List<List<Integer>> zigzagLevelOrder(TreeNode root) {List<List<Integer>> list = new ArrayList<>();helper(list, root, 0);return list;}private void helper(List<List<Integer>> list, TreeNode node, int level) {if (node == null) return;addList(list, node, level);helper(list, node.left, level + 1);helper(list, node.right, level + 1);}private void addList(List<List<Integer>> list, TreeNode node, int level) {List<Integer> cur;if (list.size() > level) cur = list.get(level);else {cur = new ArrayList<>();list.add(cur);}if (level % 2 == 1) cur.add(0, node.val);else cur.add(node.val);}
}
迭代，reverse
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode103.solution3;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.*;/*** 迭代 + reverse** @author Shockang*/
public class Solution {public List<List<Integer>> zigzagLevelOrder(TreeNode root) {Queue<TreeNode> queue = new LinkedList<>();List<List<Integer>> res = new ArrayList<>();if (root != null) {queue.offer(root);}List<Integer> list;while (!queue.isEmpty()) {int size = queue.size(); //当前层，元素的数量list = new ArrayList<>();for (int i = 0; i < size; i++) {TreeNode node = queue.poll(); //按顺序弹出队列元素，加入集合list.add(node.val);if (node.left != null) {queue.offer(node.left); //当前元素的左子树入队，即把下一层的元素加入队列}if (node.right != null) {queue.offer(node.right); //当前元素的右子树入队，即把下一层的元素加入队列}}if (res.size() % 2 == 1) { //本题中奇数层要翻转下Collections.reverse(list);}res.add(list);}return res;}
}
迭代，2个栈
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode103.solution4;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;/*** 迭代 + 2个栈** @author Shockang*/
public class Solution {public List<List<Integer>> zigzagLevelOrder(TreeNode root) {List<List<Integer>> ret = new ArrayList<>();if (root == null) return ret;Deque<TreeNode> queue = new ArrayDeque<>(), stack = new ArrayDeque<>();queue.add(root);int level = 1;///层数为奇数时，正常顺序遍历,层数为偶数,倒序遍历while (!queue.isEmpty() || !stack.isEmpty()) {boolean isOrder = (level & 1) == 1;int n = isOrder ? queue.size() : stack.size();List<Integer> sub = new ArrayList<>();for (int i = 0; i < n; i++) {if (isOrder) {TreeNode cur = queue.poll();sub.add(cur.val);if (cur.left != null) {stack.push(cur.left);}if (cur.right != null) {stack.push(cur.right);}} else {TreeNode cur = stack.poll();sub.add(cur.val);if (cur.right != null) {queue.addFirst(cur.right);}if (cur.left != null) {queue.addFirst(cur.left);}}}level++;ret.add(sub);}return ret;}
}
迭代，Queue+Deque
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode103.solution5;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;/*** 迭代 + queue + deque** @author Shockang*/
public class Solution {public List<List<Integer>> zigzagLevelOrder(TreeNode root) {List<List<Integer>> ans = new LinkedList<>();if (root == null) {return ans;}Queue<TreeNode> nodeQueue = new LinkedList<>();nodeQueue.offer(root);boolean isOrderLeft = true;while (!nodeQueue.isEmpty()) {Deque<Integer> levelList = new LinkedList<>();int size = nodeQueue.size();for (int i = 0; i < size; ++i) {TreeNode curNode = nodeQueue.poll();if (isOrderLeft) {levelList.offerLast(curNode.val);} else {levelList.offerFirst(curNode.val);}if (curNode.left != null) {nodeQueue.offer(curNode.left);}if (curNode.right != null) {nodeQueue.offer(curNode.right);}}ans.add(new LinkedList<>(levelList));isOrderLeft = !isOrderLeft;}return ans;}
}
104. 二叉树的最大深度
题解
官方题解
递归，DFS
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode104.solution1;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;/*** 递归，DFS** @author Shockang*/
public class Solution {public int maxDepth(TreeNode root) {if (root == null) return 0;return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;}
}
迭代，BFS
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode104.solution2;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.LinkedList;
import java.util.Queue;/*** 迭代，BFS** @author Shockang*/
public class Solution {public int maxDepth(TreeNode root) {if (root == null) {return 0;}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);int ans = 0;while (!queue.isEmpty()) {int size = queue.size();while (size > 0) {TreeNode node = queue.poll();if (node.left != null) {queue.offer(node.left);}if (node.right != null) {queue.offer(node.right);}size--;}ans++;}return ans;}
}
105. 从前序与中序遍历序列构造二叉树
题解
官方题解
递归
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode105.solution1;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.HashMap;
import java.util.Map;/*** 递归** @author Shockang*/
public class Solution {private Map<Integer, Integer> indexMap;public TreeNode buildTree(int[] preorder, int preLeft, int preRight, int inLeft, int inRight) {if (preLeft > preRight || inLeft > inRight) {return null;}// 前序遍历中的第一个节点就是根节点int rootVal = preorder[preLeft];// 在中序遍历中定位根节点int pIndex = indexMap.get(rootVal);// 先把根节点建立出来TreeNode root = new TreeNode(rootVal);// 递归地构造左子树，并连接到根节点// 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素root.left = buildTree(preorder, preLeft + 1, pIndex - inLeft + preLeft, inLeft, pIndex - 1);// 递归地构造右子树，并连接到根节点// 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素root.right = buildTree(preorder, pIndex - inLeft + preLeft + 1, preRight, pIndex + 1, inRight);return root;}public TreeNode buildTree(int[] preorder, int[] inorder) {int n = preorder.length;// 构造哈希映射，帮助我们快速定位根节点indexMap = new HashMap<Integer, Integer>();for (int i = 0; i < n; i++) {indexMap.put(inorder[i], i);}return buildTree(preorder, 0, n - 1, 0, n - 1);}
}
迭代
package com.shockang.study.algorithm.java.leetcode.leetcode101_200.leetcode105.solution2;import com.shockang.study.algorithm.java.leetcode.common.TreeNode;import java.util.Deque;
import java.util.LinkedList;/*** 迭代** @author Shockang*/
public class Solution {public TreeNode buildTree(int[] preorder, int[] inorder) {if (preorder == null || preorder.length == 0) {return null;}TreeNode root = new TreeNode(preorder[0]);Deque<TreeNode> stack = new LinkedList<>();stack.push(root);int inorderIndex = 0;for (int i = 1; i < preorder.length; i++) {int preorderVal = preorder[i];TreeNode node = stack.peek();if (node.val != inorder[inorderIndex]) {node.left = new TreeNode(preorderVal);stack.push(node.left);} else {while (!stack.isEmpty() && stack.peek().val == inorder[inorderIndex]) {node = stack.pop();inorderIndex++;}node.right = new TreeNode(preorderVal);stack.push(node.right);}}return root;}
}
LeetCode 101~105相关推荐
- LeetCode 101. Symmetric Tree
LeetCode 101. Symmetric Tree Solution1 参考<剑指offer>上的解法:https://blog.csdn.net/allenlzcoder/arti ...
- 自我总结：Leetcode 654, 105, 106, 889
终于算是熬过期末以后想起来了学学习了哈哈哈哈. 今天看看二叉树的构造,以下内容为自我学习总结,主要目的为学习笔记,兼职传播小想法.内容为学习labuladong的学习笔记.以下为链接,感谢大佬的学习讲 ...
- [leetcode] 101. 对称二叉树
101. 对称二叉树 一开始想复杂了呀,没有做出来 直观的思路就是反转这颗树,然后判断两颗树是不是相同的 class Solution {// 反转并创建一颗树public TreeNode reve ...
- LeetCode 101. 对称二叉树 思考分析
题目 给定一个二叉树,检查它是否是镜像对称的. 例如,二叉树 [1,2,2,3,4,4,3] 是对称的. 1 / 2 2 / \ / 3 4 4 3 但是下面这个 [1,2,2,null,3,null ...
- LeetCode 101. 对称二叉树（递归循环）
1. 题目 给定一个二叉树,检查它是否是镜像对称的. 例如,二叉树 [1,2,2,3,4,4,3] 是对称的.1/ \2 2/ \ / \ 3 4 4 3 但是下面这个 [1,2,2,null,3,n ...
- leetcode - 101. 对称二叉树
给定一个二叉树,检查它是否是镜像对称的. 例如,二叉树 [1,2,2,3,4,4,3][1,2,2,3,4,4,3][1,2,2,3,4,4,3] 是对称的. 但是下面这个 [1,2,2,null,3 ...
- LeetCode 106/105 从中序和后序/前序遍历序列构造二叉树
原理: 请参考文章:数据结构笔记:二叉树的构造(根据遍历顺序构造二叉树) 先序遍历 中序遍历 后序序列组成情况, 106后序和中序构造二叉树 题目链接:力扣 思路: 递归 递归函数声明: Tree ...
- Leetcode 101.对称二叉树
Time: 20190901 题目描述 给定一个二叉树,检查它是否是镜像对称的. 例如,二叉树 [1,2,2,3,4,4,3] 是对称的. 1/ \2 2/ \ / \ 3 4 4 3 但是下面这个 ...
- LeetCode 101：和你一起你轻松刷题（C++）总篇章正在陆续更新
文章目录 第 1 章 题目分类 第 2 章 最易懂的贪心算法 2.1 算法解释 2.2 分配问题 [455. 分发饼干] [135. 分发糖果] 2.3 区间问题 [435. 无重叠区间] [803. ...
最新文章
- Java Properties 类
- 四轴飞行器1.1 Matlab 姿态显示
- 当Project xCloud落地移动终端，云游戏靠手游撑起“当打之年”？
- fatal: unable to access 'xxxxxxxxxxxxx':The requested URL returned error: 403
- CS229 6.5 Neurons Networks Implements of Sparse Autoencoder
- 【MySql】linux下，设置mysql表名忽略大小写
- java测试开发_测试开发系类之Java常用知识点
- java微信支付异步通知_Java中微信支付退款异步通知解码
- python判定串口已连接_python 自动识别并连接串口的实现
- [WPF]根据显示区域宽度裁剪字符串
- nodejs+express 初学（一）
- 网易云音乐ios旧版本安装包_网易云音乐产品分析报告
- oracle密码过期和账户锁定
- 3dmax渲染完就卡住不动，怎么办
- SDN是什么，与传统分布式网络有什么区别
- 达思SQL数据库修复软件升级至 5.0 版本（重要升级支持修复压缩格式的备份文件）
- 微服务可用性设计(二)：过载保护，限流
- php怎么将农历转换成公历,农历公历转换器，公历农历转换
- Proxy和Reflect
- 为什么定积分可以求面积？