file_path stringlengths 27 66 | url_title stringlengths 6 38 | url stringlengths 60 237 ⌀ | difficulty stringclasses 3
values | tags listlengths 1 8 | question stringlengths 107 2.73k | solution stringlengths 163 28.6k | final stringlengths 308 330 |
|---|---|---|---|---|---|---|---|
LeetCode/991-1000/998. 最大二叉树 II（中等）.md | 998. 最大二叉树 II | https://leetcode.cn/problems/maximum-binary-tree-ii/solution/by-ac_oier-v82s/ | 中等 | [
"迭代",
"模拟"
] | 最大树定义:一棵树,并满足「其中每个节点的值都大于其子树中的任何其他值」。
给你最大树的根节点 `root` 和一个整数 `val` 。
给定的树是利用 `Construct(a)` 例程从列表 `a`(`root = Construct(a)`)递归地构建的:
* 如果 `a` 为空,返回 `null` 。
* 否则,令 `a[i]` 作为 `a` 的最大元素。创建一个值为 `a[i]` 的根节点 `root` 。
* `root` 的左子树将被构建为 `Construct([a[0], a[1], ..., a[i - 1]])` 。
* `root` 的右子树将被构建为 `Construct([a[i + 1], a[i... | ### 模拟
题意不是很好理解,先稍微解释一下吧。
大概意思是最大树 `root` 是根据特定的规则构造出来的,即给定的 `root` 其实对应一个具体的 `nums`,题目要求是将 `val` 追加到 `nums` 的尾部,然后再对得到的 `nums` 运用相同规则的构造,返回重新构造的最大树头结点。
根据构造规则,若有下标 $i < j$,则 $nums[i]$ 必然在 $nums[j]$ 水平线的左边,而 `val` 又是追加在原有 `nums` 的结尾。因此其最终位置分如下两种情况:
* `val` 为新 `nums` 中的最大值,同时 `val` 又是追加在原有 `nums` 的结尾,此时将原有的 `root` 挂... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.998` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/LCP/LCP 07. 传递信息（简单）.md | LCP 07. 传递信息 | https://leetcode-cn.com/problems/chuan-di-xin-xi/solution/gong-shui-san-xie-tu-lun-sou-suo-yu-dong-cyxo/ | 简单 | [
"图论搜索",
"图论 BFS",
"图论 DFS",
"线性 DP"
] | 小朋友 A 在和 ta 的小伙伴们玩传信息游戏,游戏规则如下:
1. 有 n 名玩家,所有玩家编号分别为 0 ~ n-1,其中小朋友 A 的编号为 0
2. 每个玩家都有固定的若干个可传信息的其他玩家(也可能没有)。传信息的关系是单向的(比如 A 可以向 B 传信息,但 B 不能向 A 传信息)。
3. 每轮信息必须需要传递给另一个人,且信息可重复经过同一个人
给定总玩家数 n,以及按 [玩家编号,对应可传递玩家编号] 关系组成的二维数组 relation。返回信息从小 A (编号 0 ) 经过 k 轮传递到编号为 n-1 的小伙伴处的方案数;若不能到达,返回 0。
示例 1:
```
输入:n = 5, relation =... | ### 基本分析
`n` 和 `k` 的数据范围都很小,并且根据题目对 `relation` 的定义可以知道这是一个边权相等的图。
对于边权相等的图,统计有限步数的到达某个节点的方案数,最常见的方式是使用 `BFS` 或 `DFS`。
---
### BFS
一个朴素的做法是使用 `BFS` 进行求解。
起始时,将起点入队,按照常规的 `BFS` 方式进行拓展,直到拓展完第 $k$ 层。
然后统计队列中编号为 `n-1` 的节点的出现次数。
一些细节:为了方便找到某个点 $i$ 所能到达的节点,我们需要先预处理出所有的边。数据量较少,直接使用 `Map` 套 `Set` 即可。
代码:
```Java
class ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `LCP 07` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/LCR/LCR 161. 连续天数的最高销售额（简单）.md | LCR 161. 连续天数的最高销售额 | https://leetcode.cn/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/solution/gong-shui-san-xie-tu-jie-cong-on-chang-g-se9p/ | 简单 | [
"前缀和",
"区间求和问题",
"线性 DP",
"分治"
] | 某公司每日销售额记于整数数组 `sales`,请返回所有连续一或多天销售额总和的最大值。
要求实现时间复杂度为 $O(n)$ 的算法。
示例 1:
```
输入:sales = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:[4,-1,2,1] 此连续四天的销售总额最高,为 6。
```
示例 2:
```
输入:sales = [5,4,-1,7,8]
输出:23
解释:[5,4,-1,7,8] 此连续五天的销售总额最高,为 23。
```
提示:
* $1 <= arr.length <= 10^5$
* $-100 <= arr[i] <= 100$ | ### 前缀和 or 线性 DP
当要我们求「连续段」区域和的时候,要很自然的想到「前缀和」。
所谓前缀和,是指对原数组“累计和”的描述,通常是指一个与原数组等长的数组。
设前缀和数组为 `sum`,**`sum` 的每一位记录的是从「起始位置」到「当前位置」的元素和**。例如 $sum[x]$ 是指原数组中“起始位置”到“位置 `x`”这一连续段的元素和。
有了前缀和数组 `sum`,当我们求连续段 $[i, j]$ 的区域和时,利用「容斥原理」,便可进行快速求解。
通用公式:`ans = sum[j] - sum[i - 1]`。
由于涉及 `-1` 操作,为减少边界处理,我们可让前缀和数组下标从 $1$ 开始。在进... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.LCR 161` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 003. 前 n 个数字二进制中 1 的个数（简单）.md | 剑指 Offer II 003. 前 n 个数字二进制中 1 的个数 | https://leetcode.cn/problems/w3tCBm/solution/by-ac_oier-cnlt/ | 简单 | [
"模拟",
"动态规划"
] | 给定一个非负整数 `n` ,请计算 `0` 到 `n` 之间的每个数字的二进制表示中 $1$ 的个数,并输出一个数组。
示例 1:
```
输入: n = 2
输出: [0,1,1]
解释:
0 --> 0
1 --> 1
2 --> 10
```
示例 2:
```
输入: n = 5
输出: [0,1,1,2,1,2]
解释:
0 --> 0
1 --> 1
2 --> 10
3 --> 11
4 --> 100
5 --> 101
```
说明 :
* $0 <= n <= 10^5$
进阶:
* 给出时间复杂度为 $O(n \times sizeof(integer))$ 的解答非常容易。但你可以在线性时间 ... | ### 模拟
这道题要对每个数进行统计,因此不会有比 $O(n)$ 更低的做法。
而很容易想到的朴素做法是对每个数进行「位运算」计数,每个数都是 $32$ 位的,因此是一个 $O(32n)$ 的做法。
代码:
```Java
class Solution {
public int[] countBits(int n) {
int[] ans = new int[n + 1];
for (int i = 0; i <= n; i++) ans[i] = getCnt(i);
return ans;
}
int getCnt(int u) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 003` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 005. 单词长度的最大乘积（中等）.md | 剑指 Offer II 005. 单词长度的最大乘积 | https://leetcode.cn/problems/aseY1I/solution/by-ac_oier-qk3a/ | 中等 | [
"模拟",
"位运算"
] | 给定一个字符串数组 `words`,请计算当两个字符串 `words[i]` 和 `words[j]` 不包含相同字符时,它们长度的乘积的最大值。假设字符串中只包含英语的小写字母。如果没有不包含相同字符的一对字符串,返回 $0$。
示例 1:
```
输入: words = ["abcw","baz","foo","bar","fxyz","abcdef"]
输出: 16
解释: 这两个单词为 "abcw", "fxyz"。它们不包含相同字符,且长度的乘积最大。
```
示例 2:
```
输入: words = ["a","ab","abc","d","cd","bcd","abcd"]
输出: 4
解释: 这两个单... | ### 模拟
根据题意进行模拟即可,利用每个 $words[i]$ 只有小写字母,且只需要区分两字符是否有字母重复。
我们可以使用一个 `int` 来代指某个 $word[i]$:低 $26$ 来代指字母 `a-z` 是否出现过。
然后对每个「字符对」所对应的两个 `int` 值执行 `&` 操作(若两字符无重复字符,则结果为 $0$),并得出最终答案。
代码:
```Java []
class Solution {
public int maxProduct(String[] words) {
int n = words.length, idx = 0;
int[] masks = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 005` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 007. 数组中和为 0 的三个数（中等）.md | 剑指 Offer II 007. 数组中和为 0 的三个数 | https://leetcode.cn/problems/1fGaJU/solution/by-ac_oier-6mfb/ | 中等 | [
"双指针",
"排序",
"n 数之和"
] | 给你一个包含 $n$ 个整数的数组 `nums`,判断 `nums` 中是否存在三个元素 `a`,`b`,`c` ,使得 `a + b + c = 0` ?
请你找出所有和为 $0$ 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
示例 1:
```
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
```
示例 2:
```
输入:nums = []
输出:[]
```
示例 3:
```
输入:nums = [0]
输出:[]
```
提示:
* $0 <= nums.length <= 3000$
* $-10^5 <= nums[i] <= 10^5... | ### 排序 + 双指针
对数组进行排序,使用三个指针 `i`、`j` 和 `k` 分别代表要找的三个数。
1. 通过枚举 `i` 确定第一个数,另外两个指针 `j`,`k` 分别从左边 `i + 1` 和右边 `n - 1` 往中间移动,找到满足 `nums[i] + nums[j] + nums[k] == 0` 的所有组合。
2. `j` 和 `k` 指针的移动逻辑,分情况讨论 `sum = nums[i] + nums[j] + nums[k]` :
* `sum` > 0:`k` 左移,使 `sum` 变小
* `sum` < 0:`j` 右移,使 `sum` 变大
* `sum` = 0:找... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 007` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 008. 和大于等于 target 的最短子数组（中等）.md | 剑指 Offer II 008. 和大于等于 target 的最短子数组 | https://leetcode.cn/problems/2VG8Kg/solution/by-ac_oier-vw5r/ | 中等 | [
"前缀和",
"二分"
] | 给定一个含有 `n` 个正整数的数组和一个正整数 `target`。
找出该数组中满足其和 `≥ target` 的长度最小的 连续子数组 $[nums_{l}, nums_{l+1}, ..., nums_{r-1}, nums_{r}]$ ,并返回其长度。如果不存在符合条件的子数组,返回 $0$ 。
示例 1:
```
输入:target = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
```
示例 2:
```
输入:target = 4, nums = [1,4,4]
输出:1
```
示例 3:
```
输入:target = 11, num... | ### 前缀和 + 二分
利用 $nums[i]$ 的数据范围为 $[1, 10^5]$,可知前缀和数组满足「单调递增」。
我们先预处理出前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于每个 $nums[i]$ 而言,假设其对应的前缀和值为 $s = sum[i + 1]$,我们将 $nums[i]$ 视为子数组的右端点,问题转换为:在前缀和数组下标 $[0, i]$ 范围内找到满足「**值小于等于 $s - t$**」的最大下标,充当子数组左端点的前一个值。
利用前缀和数组的「单调递增」(即具有二段性),该操作可使用「二分」来做。
代码:
```Java
class Solution {
publ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 008` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 009. 乘积小于 K 的子数组（中等）.md | 剑指 Offer II 009. 乘积小于 K 的子数组 | https://leetcode.cn/problems/ZVAVXX/solution/by-ac_oier-lop5/ | 中等 | [
"滑动窗口",
"双指针"
] | 给你一个整数数组 `nums` 和一个整数 $k$ ,请你返回子数组内所有元素的乘积严格小于 $k$ 的连续子数组的数目。
示例 1:
```
输入:nums = [10,5,2,6], k = 100
输出:8
解释:8 个乘积小于 100 的子数组分别为:[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
```
示例 2:
```
输入:nums = [1,2,3], k = 0
输出:0
```
提示:
* $1 <= nums.length <= 3 \times 10^4$
* $1 <= nums[i... | ### 滑动窗口
利用 $1 <= nums[i] <= 1000$,我们可以从前往后处理所有的 $nums[i]$,使用一个变量 $cur$ 记录当前窗口的乘积,使用两个变量 $j$ 和 $i$ 分别代表当前窗口的左右端点。
当 $cur >= k$ 时,我们考虑将左端点 $j$ 右移,同时消除原来左端点元素 $nums[j]$ 对 $cur$ 的贡献,直到 $cur >= k$ 不再满足,这样我们就可以得到每个右端点 $nums[i]$ 的最远左端点 $nums[j]$,从而得知以 $nums[i]$ 为结尾的合法子数组个数为 $i - j + 1$。
Java 代码:
```Java
class Solution {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 009` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 010. 和为 k 的子数组（中等）.md | 剑指 Offer II 010. 和为 k 的子数组 | https://leetcode.cn/problems/QTMn0o/solution/by-ac_oier-hr6k/ | 中等 | [
"前缀和",
"哈希表"
] | 给你一个整数数组 `nums` 和一个整数 `k` ,请你统计并返回该数组中和为 `k` 的子数组的个数 。
示例 1:
```
输入:nums = [1,1,1], k = 2
输出:2
```
示例 2:
```
输入:nums = [1,2,3], k = 3
输出:2
```
提示:
* $1 <= nums.length <= 2 \times 10^4$
* $-1000 <= nums[i] <= 1000$
* $-10^7 <= k <= 10^7$ | ### 前缀和 + 哈希表
这是一道经典的前缀和运用题。
统计以每一个 $nums[i]$ 为结尾,和为 $k$ 的子数组数量即是答案。
我们可以预处理前缀和数组 `sum`(前缀和数组下标默认从 $1$ 开始),对于求解以某一个 $nums[i]$ 为结尾的,和为 $k$ 的子数组数量,本质上是求解在 $[0, i]$ 中,`sum` 数组中有多少个值为 $sum[i + 1] - k$ 的数,这可以在遍历过程中使用「哈希表」进行同步记录。
Java 代码:
```Java
class Solution {
public int subarraySum(int[] nums, int k) {
in... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 010` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 011. 0 和 1 个数相同的子数组（中等）.md | 剑指 Offer II 011. 0 和 1 个数相同的子数组 | https://leetcode-cn.com/problems/contiguous-array/solution/gong-shui-san-xie-qian-zhui-he-ha-xi-bia-q400/ | 中等 | [
"前缀和",
"哈希表"
] | 给定一个二进制数组 `nums` , 找到含有相同数量的 $0$ 和 $1$ 的最长连续子数组,并返回该子数组的长度。
示例 1:
```
输入: nums = [0,1]
输出: 2
说明: [0, 1] 是具有相同数量0和1的最长连续子数组。
```
示例 2:
```
输入: nums = [0,1,0]
输出: 2
说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。
```
提示:
* $1 <= nums.length <= 10^5$
* `nums[i]` 不是 $0$ 就是 $1$ | ### 前缀和 + 哈希表
根据题意,我们可以轻易发现如下性质:如果答案非 $0$,那么子数组长度必然为偶数,且长度至少为 $2$。
具体的,我们在预处理前缀和时,将 $nums[i]$ 为 $0$ 的值当做 $-1$ 处理。
从而将问题转化为:**如何求得最长一段区间和为 $0$ 的子数组。** 同时使用「哈希表」来记录「某个前缀和出现的最小下标」是多少。
Java 代码:
```Java
class Solution {
public int findMaxLength(int[] nums) {
int n = nums.length, ans = 0;
int[] sum = ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 011` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 029. 排序的循环链表（中等）.md | 剑指 Offer II 029. 排序的循环链表 | https://leetcode.cn/problems/4ueAj6/solution/by-ac_oier-kqv3/ | 中等 | [
"链表",
"模拟"
] | 给定循环单调非递减列表中的一个点,写一个函数向这个列表中插入一个新元素 `insertVal`,使这个列表仍然是循环升序的。
给定的可以是这个列表中任意一个顶点的指针,并不一定是这个列表中最小元素的指针。
如果有多个满足条件的插入位置,可以选择任意一个位置插入新的值,插入后整个列表仍然保持有序。
如果列表为空(给定的节点是 `null`),需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。
示例 1:
```
输入:head = [3,4,1], insertVal = 2
输出:[3,4,1,2]
```
```
解释:在上图中,有一个包含三个元素的循环有序列表,你获得值为 3 的节点的指针,我们需... | ### 链表
这是一道常规的链表模拟题。
为了方便,我们记 `insertVal` 为 `x`,记 `head` 为 `he`。
起始我们先将待插入的节点创建出来,记为 `t`,当 `he` 为空时,直接返回 `t` 即可。
由于我们需要返回原本的头结点,因此我们先使用变量 `ans` 对原始的 `he` 进行转存,随后复用 `he` 来充当游标进行遍历。
我们先对链表进行一次完成遍历,遍历过程中维护节点最值 `max` 和 `min`,由于链表是循环的,我们需要使用 `he.next != ans` 作为我们循环的结束条件,含义为回到链表开头。
此时根据最大值和最小值是否相等(即整段链表值是否一致)来进行分情况讨论:
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 029` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器（中等）.md | 剑指 Offer II 030. 插入、删除和随机访问都是 O(1) 的容器 | https://leetcode-cn.com/problems/FortPu/solution/by-ac_oier-rls4/ | 中等 | [
"数据结构",
"哈希表"
] | 实现 `RandomizedSet` 类:
* `RandomizedSet()` 初始化 `RandomizedSet` 对象
* `bool insert(int val)` 当元素 `val` 不存在时,向集合中插入该项,并返回 `true`;否则,返回 `false`。
* `bool remove(int val)` 当元素 `val` 存在时,从集合中移除该项,并返回 `true`;否则,返回 `false`。
* `int getRandom()` 随机返回现有集合中的一项(测试用例保证调用此方法时集合中至少存在一个元素)。每个元素应该有 相同的概率 被返回。
你必须实现类的所有函数,并满足每个函数的 平均 时间复... | ### 哈希表 + 删除交换
对于 `insert` 和 `remove` 操作容易想到使用「哈希表」来实现 $O(1)$ 复杂度,但对于 `getRandom` 操作,比较理想的情况是能够在一个数组内随机下标进行返回。
将两者结合,我们可以将哈希表设计为:以入参 `val` 为键,数组下标 `loc` 为值。
**为了确保严格 $O(1)$,我们不能「使用拒绝采样」和「在数组非结尾位置添加/删除元素」。**
因此我们需要申请一个足够大的数组 `nums`(利用数据范围为 $2* 10^5$),并使用变量 `idx` 记录当前使用到哪一位(即下标在 $[0, idx]$ 范围内均是存活值)。
对于几类操作逻辑:
* `i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 030` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 041. 滑动窗口的平均值（简单）.md | 剑指 Offer II 041. 滑动窗口的平均值 | https://leetcode.cn/problems/qIsx9U/solution/by-ac_oier-g5ha/ | 简单 | [
"模拟",
"队列"
] | 给定一个整数数据流和一个窗口大小,根据该滑动窗口的大小,计算滑动窗口里所有数字的平均值。
实现 `MovingAverage` 类:
* `MovingAverage(int size)` 用窗口大小 `size` 初始化对象。
* `double next(int val)` 成员函数 `next` 每次调用的时候都会往滑动窗口增加一个整数,请计算并返回数据流中最后 `size` 个值的移动平均值,即滑动窗口里所有数字的平均值。
示例:
```
输入:
inputs = ["MovingAverage", "next", "next", "next", "next"]
inputs = [[3], [1], [10], [3... | ### 双端队列
根据题意,我们可以使用变量 `n` 将初始化传入的 `size` 进行转存,同时使用「双端队列」来存储 `next` 所追加的值(添加到队列尾部),当双端队列所包含元素超过规定数量 `n` 时,我们从队列头部进行 `pop` 操作,整个维护过程使用变量 `sum` 记录当前包含的元素和。
利用 `next` 操作最多被调用 $10^4$ 次,我们可以使用直接开个 $10^4$ 数组来充当双端队列,使用两指针 `j` 和 `i` 分别指向队列的头部和尾部。
Java 代码:
```Java
class MovingAverage {
int[] arr = new int[10010];
int... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 041` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 067. 最大的异或（中等）.md | 剑指 Offer II 067. 最大的异或 | https://leetcode.cn/problems/ms70jA/solution/by-ac_oier-d9kx/ | 中等 | [
"贪心",
"字典树"
] | 给定一个整数数组 `nums`,返回 `nums[i] XOR nums[j]` 的最大运算结果,其中 $0 ≤ i ≤ j < n$ 。
示例 1:
```
输入:nums = [3,10,5,25,2,8]
输出:28
解释:最大运算结果是 5 XOR 25 = 28.
```
示例 2:
```
输入:nums = [0]
输出:0
```
示例 3:
```
输入:nums = [2,4]
输出:6
```
示例 4:
```
输入:nums = [8,10,2]
输出:10
```
示例 5:
```
输入:nums = [14,70,53,83,49,91,36,80,92,51,66,70]
输出:127... | ### 基本分析
要求得数组 `nums` 中的「最大异或结果」,假定 $nums[i]$ 与 $nums[j]$ 异或可以取得最终结果。
**由于异或计算「每位相互独立」(又称为不进位加法),同时具有「相同值异或结果为 $0$,不同值异或结果为 $1$」的特性。**
因此对于 $nums[j]$ 而言,可以从其二进制表示中的最高位开始往低位找,尽量让每一位的异或结果为 $1$,这样找到的 $nums[i]$ 与 $nums[j]$ 的异或结果才是最大的。
具体的,我们需要先将 `nums` 中下标范围为 $[0, j]$ 的数(二进制表示)加入 $Trie$ 中,然后每次贪心的匹配每一位(优先匹配与之不同的二进制位)。
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer II 067` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题... |
LeetCode/剑指 Offer II/剑指 Offer II 069. 山峰数组的顶部（简单）.md | 剑指 Offer II 069. 山峰数组的顶部 | https://leetcode-cn.com/problems/B1IidL/solution/gong-shui-san-xie-er-fen-san-fen-ji-zhi-lc8zl/ | 简单 | [
"二分",
"三分"
] | 符合下列属性的数组 `arr` 称为 山峰数组(山脉数组) :
* `arr.length >= 3`
* 存在 `i`(`0 < i < arr.length - 1`)使得:
* `arr[0] < arr[1] < ... arr[i-1] < arr[i]`
* `arr[i] > arr[i+1] > ... > arr[arr.length - 1]`
给定由整数组成的山峰数组 arr ,返回任何满足 `arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1]` 的下标 `i` ,即山峰顶部。
示例 1:
... | ### 二分
往常我们使用「二分」进行查值,需要确保序列本身满足「二段性」:当选定一个端点(基准值)后,结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。
但本题求的是峰顶索引值,如果我们选定数组头部或者尾部元素,其实无法根据大小关系“直接”将数组分成两段。
但可以利用题目发现如下性质:**由于 `arr` 数值各不相同,因此峰顶元素左侧必然满足严格单调递增,峰顶元素右侧必然不满足。**
因此 **以峰顶元素为分割点的 `arr` 数组,根据与 前一元素/后一元素 的大小关系,具有二段性:**
* 峰顶元素左侧满足 $arr[i-1] < arr[i]$ 性质,右侧不满足
* 峰顶元素右侧满足 $arr[i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer II 069` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题... |
LeetCode/剑指 Offer II/剑指 Offer II 091. 粉刷房子（中等）.md | 剑指 Offer II 091. 粉刷房子 | https://leetcode.cn/problems/JEj789/solution/by-ac_oier-6v2v/ | 中等 | [
"状态机 DP",
"动态规划"
] | 假如有一排房子,共 `n` 个,每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种,你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。
当然,因为市场上不同颜色油漆的价格不同,所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 `n x 3` 的正整数矩阵 `costs` 来表示的。
例如,`costs[0][0]` 表示第 $0$ 号房子粉刷成红色的成本花费;`costs[1][2]` 表示第 $1$ 号房子粉刷成绿色的花费,以此类推。
请计算出粉刷完所有房子最少的花费成本。
示例 1:
```
输入: costs = [[17,2,17],[16,16,5],[14,3,19]]... | ### 状态机 DP
为了方便,我们记 `costs` 为 `cs`。
根据题意,当我们从前往后决策每间房子的颜色时,当前房子所能刷的颜色,取决于上一间房子的颜色。
我们可以定义 $f[i][j]$ 为考虑下标不超过 $i$ 的房子,且最后一间房子颜色为 $j$ 时的最小成本。
起始我们有 $f[0][i] = cs[0][i]$,代表只有第一间房子时,对应成本为第一间房子的上色成本。
然后不失一般性考虑,$f[i][j]$ 该如何计算:$f[i][j]$ 为所有 $f[i - 1][prev]$(其中 $prev \neq j$)中的最小值加上 $cs[i][j]$。
本质上这是一道「状态机 DP」问题:某些状态只能由... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 091` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 114. 外星文字典（困难）.md | 剑指 Offer II 114. 外星文字典 | https://leetcode.cn/problems/Jf1JuT/solution/by-ac_oier-4xmv/ | 困难 | [
"图论",
"拓扑排序",
"建图",
"图论 BFS"
] | 现有一种使用英语字母的外星文语言,这门语言的字母顺序与英语顺序不同。
给定一个字符串列表 `words` ,作为这门语言的词典,`words` 中的字符串已经 按这门新语言的字母顺序进行了排序 。
请你根据该词典还原出此语言中已知的字母顺序,并 按字母递增顺序 排列。若不存在合法字母顺序,返回 `""` 。若存在多种可能的合法字母顺序,返回其中 任意一种 顺序即可。
字符串 `s` 字典顺序小于 字符串 `t` 有两种情况:
在第一个不同字母处,如果 `s` 中的字母在这门外星语言的字母顺序中位于 `t` 中字母之前,那么 `s` 的字典顺序小于 `t` 。
如果前面 `min(s.length, t.length)` 字母... | ### 建图 + 拓扑排序
为了方便,我们称 `words` 为 `ws`,同时将两个字符串 `a` 和 `b` 之间的字典序关系简称为「关系」。
由于数组长度和每个 $ws[i]$ 的最大长度均为 $100$,我们可以实现复杂度为 $O(n^3)$ 的算法。
首先容易想到,我们从前往后处理每个 $ws[i]$,利用 `ws` 数组本身已按字典序排序,然后通过 $ws[i]$ 与 $ws[j]$ 的关系(其中 $j$ 的范围为 $[0, i - 1]$),来构建字符之间的关系。
具体的,当我们明确字符 $c1$ 比 $c2$ 字典序要小,可以建立从 $c1$ 到 $c2$ 的有向边,同时统计增加 $c1$ 的出度,增加 $c... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 114` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer II/剑指 Offer II 115. 重建序列（中等）.md | 剑指 Offer II 115. 重建序列 | https://leetcode.cn/problems/ur2n8P/solution/by-ac_oier-oqxs/ | 中等 | [
"图论",
"拓扑排序",
"建图",
"图论 BFS"
] | 给定一个长度为 `n` 的整数数组 `nums` ,其中 `nums` 是范围为 $[1,n]$ 的整数的排列。还提供了一个 `2D` 整数数组 `sequences`,其中 `sequences[i]` 是 `nums` 的子序列。
检查 `nums` 是否是唯一的最短 超序列 。最短 超序列 是 长度最短 的序列,并且所有序列 `sequences[i]` 都是它的子序列。对于给定的数组 `sequences`,可能存在多个有效的 超序列 。
* 例如,对于 `sequences = [[1,2],[1,3]]` ,有两个最短的 超序列,`[1,2,3]` 和 `[1,3,2]` 。
* 而对于 `sequences = [... | ### 拓扑排序 + 构造
为了方便,我们令 `sequences` 为 `ss`。
根据题意,如果我们能够利用所有的 $ss[i]$ 构造出一个唯一的序列,且该序列与 `nums` 相同,则返回 `True`,否则返回 `False`。
将每个 $ss[i]$ 看做对 $ss[i]$ 所包含点的前后关系约束,我们可以将问题转换为拓扑排序问题。
利用所有 $ss[i]$ 构造新图:对于 $ss[i] = [A_1, A_2, ..., A_k]$,我们将其转换为点 $A_1$ -> $A_2$ -> ... -> $A_k$ 的有向图,同时统计每个点的入度情况。
然后在新图上跑一遍拓扑排序,构造对应的拓扑序列,与 `num... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer II 115` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 04. 二维数组中的查找（中等）.md | 剑指 Offer 04. 二维数组中的查找 | https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/solution/by-ac_oier-7jo0/ | 中等 | [
"二叉树搜索树",
"BST",
"二分"
] | 在一个 $n \times m$ 的二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个高效的函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
示例:
```
现有矩阵 matrix 如下:
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5,返回 true。
给定 target = 20,返回 false。
```
限制:
* $0 <= n <... | ### 二分
与 [(题解)74. 搜索二维矩阵](https://leetcode-cn.com/problems/search-a-2d-matrix/solution/gong-shui-san-xie-yi-ti-shuang-jie-er-fe-l0pq/) 不同,本题没有确保「每行的第一个整数大于前一行的最后一个整数」,因此我们无法采取「两次二分」的做法。
只能退而求之,遍历行/列,然后再对列/行进行二分。
代码:
```Java
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
if (ma... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 04` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 06. 从尾到头打印链表（简单）.md | 剑指 Offer 06. 从尾到头打印链表 | https://leetcode.cn/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/solution/by-ac_oier-3qsk/ | 简单 | [
"链表",
"迭代",
"递归",
"双指针"
] | 输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)。
示例 1:
```
输入:head = [1,3,2]
输出:[2,3,1]
```
限制:
* $0 <= 链表长度 <= 10000$ | ### 迭代
使用「迭代」方式求解是极其容易的。
在遍历链表 `head` 时,使用变长数组将节点值进行转存,随后再利用变长数组来「从后往前」构造定长数组并进行返回即可(其中 `TS` 代码无须额外构造定长数组,直接在原有数组基础上使用「双指针」翻转即可)。
Java 代码:
```Java
class Solution {
public int[] reversePrint(ListNode head) {
List<Integer> list = new ArrayList<>();
while (head != null) {
list.add(head... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 06` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 10- I. 斐波那契数列（简单）.md | 剑指 Offer 10- I. 斐波那契数列 | https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof/solution/gong-shui-san-xie-yi-ti-si-jie-dong-tai-9zip0/ | 简单 | [
"动态规划",
"线性 DP",
"记忆化搜索",
"打表",
"矩阵快速幂"
] | 写一个函数,输入 n ,求斐波那契(Fibonacci)数列的第 n 项(即 F(N))。斐波那契数列的定义如下:
* F(0) = 0, F(1) = 1
* F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始,之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
示例 1:
```
输入:n = 2
输出:1
```
示例 2:
```
输入:n = 5
输出:5
```
提示:
* 0 <= n <= 100 | ### 递推实现动态规划
既然转移方程都给出了,直接根据转移方程从头到尾递递推一遍即可。
代码:
```Java
class Solution {
int mod = (int)1e9+7;
public int fib(int n) {
if (n <= 1) return n;
int a = 0, b = 1;
for (int i = 2; i <= n; i++) {
int c = a + b;
c %= mod;
a = b;
b = c;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 10- I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 11. 旋转数组的最小数字（简单）.md | 剑指 Offer 11. 旋转数组的最小数字 | https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/solution/by-ac_oier-p751/ | 简单 | [
"二分"
] | 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。
给你一个可能存在 重复 元素值的数组 `numbers`,它原来是一个升序排列的数组,并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如,数组 `[3,4,5,1,2]` 为 `[1,2,3,4,5]` 的一次旋转,该数组的最小值为 $1$。
注意,数组 `[a[0], a[1], a[2], ..., a[n-1]]` 旋转一次 的结果为数组 `[a[n-1], a[0], a[1], a[2], ..., a[n-2]]`。
示例 1:
```
输入:numbers = [3,4,5,1,2]
输出:1
```
示例 2:
```
输入:nu... | ### 二分
根据题意,我们知道,所谓的旋转其实就是「将某个下标前面的所有数整体移到后面,使得数组从整体有序变为分段有序」。
但和 [153. 寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/solution/gong-shui-san-xie-yan-ge-olognyi-qi-kan-6d969/) 不同的是,本题元素并不唯一。
**这意味着我们无法直接根据与** $nums[0]$ **的大小关系,将数组划分为两段,即无法通过「二分」来找到旋转点。**
**因为「二分」的本质是二段性,并非单调性。只... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 15. 二进制中1的个数（简单）.md | 剑指 Offer 15. 二进制中1的个数 | https://leetcode-cn.com/problems/er-jin-zhi-zhong-1de-ge-shu-lcof/solution/gong-shui-san-xie-yi-ti-si-jie-wei-shu-j-g9w6/ | 简单 | [
"位运算",
"分治"
] | 请实现一个函数,输入一个整数(以二进制串形式),输出该数二进制表示中 1 的个数。例如,把 9 表示成二进制是 1001,有 2 位是 1。因此,如果输入 9,则该函数输出 2。
示例 1:
```
输入:00000000000000000000000000001011
输出:3
解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'。
```
示例 2:
```
输入:00000000000000000000000010000000
输出:1
解释:输入的二进制串 00000000000000000000000010000000 中,共有一位为 '1'。
```
示例 3:... | ### 「位数检查」解法
一个朴素的做法是,对 `int` 的每一位进行检查,并统计 $1$ 的个数。
代码:
```Java
public class Solution {
public int hammingWeight(int n) {
int ans = 0;
for (int i = 0; i < 32; i++) {
ans += ((n >> i) & 1);
}
return ans;
}
}
```
* 时间复杂度:$O(k)$,$k$ 为 `int` 的位数,固定为 $32$ 位
* 空间复杂度:$O(1)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 15` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 20. 表示数值的字符串（中等）.md | 剑指 Offer 20. 表示数值的字符串 | https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/solution/gong-shui-san-xie-chang-gui-zi-fu-chuan-sduvz/ | 中等 | [
"模拟"
] | 请实现一个函数用来判断字符串是否表示数值(包括整数和小数)。
**数值**(按顺序)可以分成以下几个部分:
1. 若干空格
2. 一个 小数 或者 整数
3. (可选)一个 `'e'` 或 `'E'` ,后面跟着一个 整数
4. 若干空格
**小数**(按顺序)可以分成以下几个部分:
1. (可选)一个符号字符(`'+'` 或 `'-'`)
2. 下述格式之一:
1. 至少一位数字,后面跟着一个点 `'.'`
2. 至少一位数字,后面跟着一个点 `'.'` ,后面再跟着至少一位数字
3. 一个点 `'.'` ,后面跟着至少一位数字
**整数**(按顺序)可以分成以下几个部分:
1. (可选)一个符号字符(`'+'`... | ### 模拟
我们对题面中的「数值」、「小数」和「整数」进行重新定义。
* 整数:可以有 `'+'` 或 `'-'`,但不能同时存在;且至少有一个数字
* 小数:可以有 `'+'` 或 `'-'`,但不能同时存在;有 `.`,且 `.` 的两边至少有一个数字
* 数值:前后可以有连续段的空格,其余位置则不能有;可以有 `E/e`,但最多只能有一个,同时 `E/e` 分割的左边可以是「整数」或「小数」,右边则只能是「整数」
根据上面的重新定义,再来设计我们的基本处理流程:
* 将 `s` 两端的连续段空格进行去除,得到不该含有空格的核心串,若核心串为空,则返回 `False`;
* 将所有的小写 `e` 切换为 `E`
* 从... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 20` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 22. 链表中倒数第k个节点（简单）.md | 剑指 Offer 22. 链表中倒数第k个节点 | https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/solution/gong-shui-san-xie-yi-ti-san-jie-zhan-dui-w3rz/ | 简单 | [
"链表",
"栈",
"队列",
"快慢指针"
] | 输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。
例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
示例:
```
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
``` | ### 栈/队列 解法
一个使用额外空间的解法是利用栈(队列),将所有的节点压入占中栈(队列)中,令当前栈(队列)容量为 $cnt$。
然后从栈顶(队列头)弹出 $k$ 个($cnt - k + 1$ 个)元素,最后一个出栈(出队列)的元素即是答案。
代码(栈):
```Java
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
Deque<ListNode> d = new ArrayDeque<>();
while (head != null) {
d.addLast(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 22. 链表中倒数第k个节点` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题... |
LeetCode/剑指 Offer/剑指 Offer 24. 反转链表（简单）.md | 剑指 Offer 24. 反转链表 | https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/solution/by-ac_oier-nqfc/ | 简单 | [
"链表",
"迭代",
"递归"
] | 定义一个函数,输入一个链表的头节点,反转该链表并输出反转后链表的头节点。
示例:
```
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
```
限制:
* $0 <= 节点个数 <= 5000$ | ### 迭代
迭代做法只需要使用两个指针即可,复用 `head` 变量来代指当前处理到的节点,使用 `prev` 变量代指原链表中 `head` 的上一节点,只需使用循环构造出所有的 `head.next = prev` 关系即可。
Java 代码:
```Java
class Solution {
public ListNode reverseList(ListNode head) {
ListNode prev = null;
while (head != null) {
ListNode temp = head.next;
head.n... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 24` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 25. 合并两个排序的链表（简单）.md | 剑指 Offer 25. 合并两个排序的链表 | https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/solution/by-ac_oier-d6wf/ | 简单 | [
"链表",
"迭代",
"递归"
] | 输入两个递增排序的链表,合并这两个链表并使新链表中的节点仍然是递增排序的。
示例1:
```
输入:1->2->4, 1->3->4
输出:1->1->2->3->4->4
```
限制:
* $0 <= 链表长度 <= 1000$ | ### 迭代 - 二路归并
使用「迭代」方式求解的话,本质与合并两个有序数组并无区别。
创建一个虚拟头结点 `dummy` 来拼接合并后的链表,`cur` 代表当前合并链表的末尾位置,同时复用入参的 `l1` 和 `l2` 来进行构造。
当 `l1` 和 `l2` 均不为空的时候,找到两者中的较小值拼接到 `cur ` 的后面,若 `l1` 和 `l2` 任一为空,则将另外的链表拼接完。
Java 代码:
```Java
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode dummy =... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 32 - I. 从上到下打印二叉树（中等）.md | 剑指 Offer 32 - I. 从上到下打印二叉树 | https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/solution/by-ac_oier-a9n5/ | 中等 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: `[3,9,20,null,null,15,7]`,
```
3
/ \
9 20
/ \
15 7
```
返回:
```
[3,9,20,15,7]
```
提示:
* `节点总数 <= 1000` | ### 迭代 - BFS
使用「迭代」进行求解是容易的,只需使用常规的 `BFS` 方法进行层序遍历即可。
Java 代码:
```Java
class Solution {
public int[] levelOrder(TreeNode root) {
List<Integer> list = new ArrayList<>();
Deque<TreeNode> d = new ArrayDeque<>();
if (root != null) d.addLast(root);
while (!d.isEmpty()) {
Tre... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题... |
LeetCode/剑指 Offer/剑指 Offer 32 - II. 从上到下打印二叉树 II（简单）.md | 剑指 Offer 32 - II. 从上到下打印二叉树 II | https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/solution/by-ac_oier-s9jz/ | 简单 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 从上到下按层打印二叉树,同一层的节点按从左到右的顺序打印,每一层打印到一行。
例如:
给定二叉树: `[3,9,20,null,null,15,7]`,
```
3
/ \
9 20
/ \
15 7
```
返回其层次遍历结果:
```
[
[3],
[9,20],
[15,7]
]
```
提示:
* `节点总数 <= 1000` | ### 迭代 - BFS
这道题是 [(题解)剑指 Offer 32 - I. 从上到下打印二叉树](https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/solution/by-ac_oier-a9n5/) 的练习版本。
只需要在每次 `BFS` 拓展时,将完整的层进行取出,存如独立数组后再加入答案。
Java 代码:
```Java
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
Deque<TreeNode> d =... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - II` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选... |
LeetCode/剑指 Offer/剑指 Offer 32 - III. 从上到下打印二叉树 III（中等）.md | 剑指 Offer 32 - III. 从上到下打印二叉树 III | https://leetcode.cn/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/solution/by-ac_oier-98od/ | 中等 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 请实现一个函数按照之字形顺序打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右到左的顺序打印,第三行再按照从左到右的顺序打印,其他行以此类推。
例如:
给定二叉树: `[3,9,20,null,null,15,7]`,
```
3
/ \
9 20
/ \
15 7
```
返回其层次遍历结果:
```
[
[3],
[20,9],
[15,7]
]
```
提示:
* `节点总数 <= 1000` | ### 迭代 - BFS
这题相比于前两道二叉树打印题目,增加了打印方向的要求。
在 `BFS` 过程中,入队我们可以仍然采用「左子节点优先入队」进行,而在出队构造答案时,我们则要根据当前所在层数来做判别:对于所在层数为偶数(`root` 节点在第 $0$ 层),我们按照「出队添加到尾部」的方式进行;对于所在层数为奇数,我们按照「出队添加到头部」的方式进行。
> 为支持「从尾部追加元素」和「从头部追加元素」操作,`Java` 可使用基于链表的 `LinkedList`,而 `TS` 可创建定长数组后通过下标赋值。
其中判断当前所在层数,无须引用额外变量,直接根据当前 `ans` 的元素大小即可。
Java 代码:
```J... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 32 - III` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优... |
LeetCode/剑指 Offer/剑指 Offer 34. 二叉树中和为某一值的路径（中等）.md | 剑指 Offer 34. 二叉树中和为某一值的路径 | https://leetcode.cn/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/solution/by-ac_oier-3ehr/ | 中等 | [
"二叉树",
"DFS",
"BFS",
"递归",
"迭代"
] | 给你二叉树的根节点 `root` 和一个整数目标和 `targetSum`,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。
示例 1:
```
输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出:[[5,4,11,2],[5,8,4,5]]
```
示例 2:
```
输入:root = [1,2,3], targetSum = 5
输出:[]
```
示例 3:
```
输入:root = [1,2], targetSum = 0
输出:[]
```
提示:
* 树中节点总数在范围 $... | ### DFS
较为直观的做法是使用 `DFS`,在 `DFS` 过程中记录路径以及路径对应的元素和,当出现元素和为 `target`,且到达了叶子节点,说明找到了一条满足要求的路径,将其加入答案。
使用 `DFS` 的好处是在记录路径的过程中可以使用「回溯」的方式进行记录及回退,而无须时刻进行路径数组的拷贝。
Java 代码:
```Java
class Solution {
List<List<Integer>> ans = new ArrayList<>();
int t;
public List<List<Integer>> pathSum(TreeNode root, int target)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 34` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 35. 复杂链表的复制（中等）.md | 剑指 Offer 35. 复杂链表的复制 | https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof/solution/by-ac_oier-6atv/ | 中等 | [
"哈希表",
"链表"
] | 给你一个长度为 `n` 的链表,每个节点包含一个额外增加的随机指针 `random`,该指针可以指向链表中的任何节点或空节点。
构造这个链表的 深拷贝。 深拷贝应该正好由 `n` 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 `next` 指针和 `random` 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
例如,如果原链表中有 `X` 和 `Y` 两个节点,其中 `X.random --> Y` 。那么在复制链表中对应的两个节点 `x` 和 `y` ,同样有 `x.random --> y` 。
返回复制链... | ### 模拟 + 哈希表
如果不考虑 `random` 指针的话,对一条链表进行拷贝,我们只需要使用两个指针:一个用于遍历原链表,一个用于构造新链表(始终指向新链表的尾部)即可。这一步操作可看做是「创建节点 + 构建 `next` 指针关系」。
现在在此基础上增加一个 `random` 指针,我们可以将 `next` 指针和 `random` 指针关系的构建拆开进行:
1. 先不考虑 `random` 指针,和原本的链表复制一样,创建新新节点,并构造 `next` 指针关系,同时使用「哈希表」记录原节点和新节点的映射关系;
2. 对原链表和新链表进行同时遍历,对于原链表的每个节点上的 `random` 都通过「哈希表」找到对应... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 35` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 37. 序列化二叉树（困难）.md | 剑指 Offer 37. 序列化二叉树 | https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof/solution/gong-shui-san-xie-er-cha-shu-de-xu-lie-h-n89a/ | 困难 | [
"二叉树",
"层序遍历"
] | 序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。
示例 1:
```
输入:root = [1,2,3,null,null,4,5]
输出:[1,2,3... | ### 基本思路
无论使用何种「遍历方式」进行二叉树存储,为了方便,我们都需要对空节点有所表示。
其实题目本身的样例就给我们提供了很好的思路:**使用层序遍历的方式进行存储,对于某个叶子节点的空节点进行存储,同时确保不递归存储空节点对应的子节点。**
---
### 层序遍历
根据节点值的数据范围 `-1000 <= Node.val <= 1000`(我是在 [297. 二叉树的序列化与反序列化](https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/) 看的,你也可以不使用数字,使用某个特殊字符进行表示,只要能在反序列时有所区分即可... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 37` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 38. 字符串的排列（中等）.md | 剑指 Offer 38. 字符串的排列 | https://leetcode-cn.com/problems/zi-fu-chuan-de-pai-lie-lcof/solution/gong-shui-san-xie-tong-yong-shi-xian-qu-4jbkj/ | 中等 | [
"字符串",
"回溯算法"
] | 输入一个字符串,打印出该字符串中字符的所有排列。
你可以以任意顺序返回这个字符串数组,但里面不能有重复元素。
示例:
```
输入:s = "abc"
输出:["abc","acb","bac","bca","cab","cba"]
```
限制:
* 1 <= s 的长度 <= 8 | ### 基本分析
根据题意,我们需要返回所有不重复的排列字符串。
此类问题通常都是使用 `DFS` 来做:**决策当前字符串的某一位填入什么字符。**
设计如下 `DFS` 函数:
```Java
/**
* cs : 原字符串
* u : 当前决策到目标字符串的哪一位
* cur : 当前目标字符串
*/
void dfs(char[] cs, int u, String cur);
```
而对于去重通常有两种方式:
1. 使用 `Set` 实现去重;
2. 先对原字符串进行排序,然后确保相同字符传入同一目标位置的动作只发生一次。
---
### 回溯(Set 去重)
使用 `HashSet... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 38` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 41. 数据流中的中位数（困难）.md | 剑指 Offer 41. 数据流中的中位数 | https://leetcode.cn/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof/solution/by-ac_oier-exn5/ | 困难 | [
"优先队列(堆)"
] | 中位数是有序列表中间的数。如果列表长度是偶数,中位数则是中间两个数的平均值。
例如,
* `[2,3,4]` 的中位数是 $3$
* `[2,3]` 的中位数是 $(2 + 3) / 2 = 2.5$
设计一个支持以下两种操作的数据结构:
* `void addNum(int num)` - 从数据流中添加一个整数到数据结构中。
* `double findMedian()` - 返回目前所有元素的中位数。
示例:
```
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2
```
进阶:
* 如果数据流中所有整数都在 $0$ 到 $10... | ### 优先队列(堆)
这是一道经典的数据结构运用题。
具体的,**我们可以使用两个优先队列(堆)来维护整个数据流数据,令维护数据流左半边数据的优先队列(堆)为 `l`,维护数据流右半边数据的优先队列(堆)为 `r`**。
显然,**为了可以在 $O(1)$ 的复杂度内取得当前中位数,我们应当令 `l` 为大根堆,`r` 为小根堆,并人为固定 `l` 和 `r` 之前存在如下的大小关系**:
* **当数据流元素数量为偶数:`l` 和 `r` 大小相同,此时动态中位数为两者堆顶元素的平均值;**
* **当数据流元素数量为奇数:`l` 比 `r` 多一,此时动态中位数为 `l` 的堆顶原数。**
为了满足上述说的奇偶性堆大... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `剑指 Offer 41` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 42. 连续子数组的最大和（简单）.md | 剑指 Offer 42. 连续子数组的最大和 | https://leetcode-cn.com/problems/lian-xu-zi-shu-zu-de-zui-da-he-lcof/solution/gong-shui-san-xie-jian-dan-xian-xing-dp-mqk5v/ | 简单 | [
"线性 DP"
] | 输入一个整型数组,数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
要求时间复杂度为$O(n)$。
示例1:
```
输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。
```
提示:
* 1 <= arr.length <= $10^5$
* -100 <= arr[i] <= 100 | ### 动态规划
这是一道简单线性 DP 题。
定义 $f[i]$ 为考虑以 $nums[i]$ 为结尾的子数组的最大值。
不失一般性的考虑 $f[i]$ 如何转移。
显然对于 $nums[i]$ 而言,以它为结尾的子数组分两种情况:
* $num[i]$ 自身作为独立子数组:$f[i] = nums[i]$ ;
* $num[i]$ 与之前的数值组成子数组,由于是子数组,其只能接在 $nums[i - 1]$,即有:$f[i] = f[i - 1] + nums[i]$。
最终 $f[i]$ 为上述两种情况取 $\max$ 即可:
$$
f[i] = \max(nums[i], f[i - 1] + nums[i])... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 42` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 44. 数字序列中某一位的数字（中等）.md | 剑指 Offer 44. 数字序列中某一位的数字 | https://leetcode.cn/problems/shu-zi-xu-lie-zhong-mou-yi-wei-de-shu-zi-lcof/solution/by-ac_oier-wgr8/ | 中等 | [
"数学",
"模拟"
] | 数字以 `0123456789101112131415...` 的格式序列化到一个字符序列中。在这个序列中,第 $5$ 位(从下标 $0$ 开始计数)是 $5$,第 $13$ 位是 $1$,第 $19$ 位是 $4$,等等。
请写一个函数,求任意第 $n$ 位对应的数字。
示例 1:
```
输入:n = 3
输出:3
```
示例 2:
```
输入:n = 11
输出:0
```
限制:
* $0 <= n < 2^31$ | ### 模拟
我们知道,对于长度为 $len$ 的数字的范围为 $[10^{len - 1}, 10^{len} - 1]$(共 $9 \times 10^{len - 1}$ 个),总长度为:
$$
L = len \times 9 \times 10^{len - 1}
$$
因此我们可以先对 $n$ 进行不断试减(更新 $n$),确定下来目标数字 $x$ 的长度为多少,假设为 $len$。
然后直接计算出长度 $len$ 的最小值为 $s = 10^{len - 1}$,由于范围内的数长度都是 $len$,因此我们可以直接定位到目标数字 $x$ 为何值。
根据目标值 $x$ 必然满足关系式:
$$
(x - s +... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 44` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 52. 两个链表的第一个公共节点（简单）.md | 剑指 Offer 52. 两个链表的第一个公共节点 | https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/solution/gong-shui-san-xie-zhao-liang-tiao-lian-b-ifqw/ | 简单 | [
"链表"
] | 输入两个链表,找出它们的第一个公共节点。
如下面的两个链表:
在节点 c1 开始相交。
示例 1:
```
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Reference of the node with value = 8
输入解释:相交节点的值为 8 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
```
示例 2... | ### 朴素解法
一个朴素的解法自然是两层枚举,逐个检查哪个节点相同。
代码:
```Java
public class Solution {
public ListNode getIntersectionNode(ListNode a, ListNode b) {
for (ListNode h1 = a; h1 != null ; h1 = h1.next) {
for (ListNode h2 = b; h2 != null ; h2 = h2.next) {
if (h1 == h2) return h1;
}
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 52` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/剑指 Offer/剑指 Offer 53 - I. 在排序数组中查找数字 I（简单）.md | 剑指 Offer 53 - I. 在排序数组中查找数字 I | https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solution/gong-shui-san-xie-liang-chong-er-fen-ton-3epx/ | 简单 | [
"二分"
] | 统计一个数字在排序数组中出现的次数。
示例 1:
```
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
```
示例 2:
```
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
```
限制:
* 0 <= 数组长度 <= 50000 | ### 二分单边 + 线性扫描
一个朴素的想法是,找到目标值 $target$ 「首次」出现或者「最后」出现的下标,然后「往后」或者「往前」进行数量统计。
代码:
```Java
// 找到目标值「最后」出现的分割点,并「往前」进行统计
class Solution {
public int search(int[] nums, int t) {
int n = nums.length;
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nu... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 53 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题... |
LeetCode/剑指 Offer/剑指 Offer 53 - II. 0～n-1中缺失的数字（简单）.md | 剑指 Offer 53 - II. 0~n-1中缺失的数字 | https://leetcode.cn/problems/que-shi-de-shu-zi-lcof/solution/by-ac_oier-gs6q/ | 简单 | [
"二分"
] | 一个长度为 $n-1$ 的递增排序数组中的所有数字都是唯一的,并且每个数字都在范围 $[0, n-1]$ 之内。
在范围 $[0, n-1]$ 内的 $n$ 个数字中有且只有一个数字不在该数组中,请找出这个数字。
示例 1:
```
输入: [0,1,3]
输出: 2
```
示例 2:
```
输入: [0,1,2,3,4,5,6,7,9]
输出: 8
```
限制:
* $1 <= 数组长度 <= 10000$ | ### 二分
强调过无数次,二分的本质是「二段性」。
我们可以考虑对于一个给定数组 `nums` 中,对于缺失元素左右数值而言,有何性质。
假设我们缺失的元素数值为 `x`,那么对于 `x` 左边的元素(若有)必然是完整且连续的,也就是其必然满足 `nums[i] = i`,而其右边的元素(若有)必然由于 `x` 的缺失,导致必然不满足 `nums[i] = i`,因此在以缺失元素为分割点的数轴上,具有二段性,我们可以使用「二分」来找该分割点。
同时由于缺失元素可能是 $[0, n - 1]$ 范围内的最大值,因此我们需要二分结束后再 `check` 一次,若不满足,说明缺失的元素值为 $n - 1$。
Java 代码:
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 53 - II` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选... |
LeetCode/剑指 Offer/剑指 Offer 59 - I. 滑动窗口的最大值（困难）.md | 剑指 Offer 59 - I. 滑动窗口的最大值 | https://leetcode.cn/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/solution/by-ac_oier-sjym/ | 困难 | [
"优先队列(堆)",
"线段树",
"分块",
"单调队列",
"RMQ"
] | 给你一个整数数组 `nums`,有一个大小为 `k` 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 `k` 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值 。
示例 1:
```
输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
输出:[3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5]... | ### 优先队列(堆)
根据题意,容易想到优先队列(大根堆),同时为了确保滑动窗口的大小合法性,我们以二元组 $(idx, nums[idx])$ 的形式进行入队。
当下标达到首个滑动窗口的右端点后,每次尝试从优先队列(大根堆)中取出最大值(若堆顶元素的下标小于当前滑动窗口左端点时,则丢弃该元素)。
代码:
```Java
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->b[1]-a[1]);
i... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.剑指 Offer 59 - I` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题... |
LeetCode/面试题/面试题 01.02. 判定是否互为字符重排（简单）.md | 面试题 01.02. 判定是否互为字符重排 | https://leetcode.cn/problems/check-permutation-lcci/solution/by-ac_oier-qj3j/ | 简单 | [
"模拟"
] | 给定两个字符串 `s1` 和 `s2`,请编写一个程序,确定其中一个字符串的字符重新排列后,能否变成另一个字符串。
示例 1:
```
输入: s1 = "abc", s2 = "bca"
输出: true
```
示例 2:
```
输入: s1 = "abc", s2 = "bad"
输出: false
```
说明:
* $0 <= len(s1) <= 100$
* $0 <= len(s2) <= 100$ | ### 模拟
根据题意,对两字符串进行词频统计,统计过程中使用变量 `tot` 记录词频不同的字符个数。
Java 代码:
```Java
class Solution {
public boolean CheckPermutation(String s1, String s2) {
int n = s1.length(), m = s2.length(), tot = 0;
if (n != m) return false;
int[] cnts = new int[128];
for (int i = 0; i < n; i++) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.02` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 01.05. 一次编辑（中等）.md | 面试题 01.05. 一次编辑 | https://leetcode.cn/problems/one-away-lcci/solution/by-ac_oier-7ml0/ | 中等 | [
"模拟",
"双指针"
] | 字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。 给定两个字符串,编写一个函数判定它们是否只需要一次(或者零次)编辑。
示例 1:
```
输入:
first = "pale"
second = "ple"
输出: True
```
示例 2:
```
输入:
first = "pales"
second = "pal"
输出: False
``` | ### 双指针模拟
为了方便,我们令 $a = first$、$b = second$,两者长度为 $n$ 和 $m$,并让 $a$ 为两种中的长度较短的那个(若 $b$ 较短,则将两者交换)。
接下来是简单的双指针处理(使用 $cnt$ 记录操作次数):
1. 我们最多使用不超过一次的操作,因此如果 $\left | n - m \right | > 1$,直接返回 `False`;
2. 若两者长度差不超过 $1$,使用 $i$ 和 $j$ 分别指向两字符的最左侧进行诸位检查:
* 若 $a[i] = b[j]$,让 $i$ 和 $j$ 继续后移进行检查;
* 若 $a[i] \neq b[j]$,根据两字... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.05` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 01.08. 零矩阵（中等）.md | 面试题 01.08. 零矩阵 | https://leetcode.cn/problems/zero-matrix-lcci/solution/by-ac_oier-0lo0/ | 中等 | [
"模拟"
] | 编写一种算法,若 $M \times N$ 矩阵中某个元素为 $0$,则将其所在的行与列清零。
示例 1:
```
输入:
[
[1,1,1],
[1,0,1],
[1,1,1]
]
输出:
[
[1,0,1],
[0,0,0],
[1,0,1]
]
```
示例 2:
```
输入:
[
[0,1,2,0],
[3,4,5,2],
[1,3,1,5]
]
输出:
[
[0,0,0,0],
[0,4,5,0],
[0,3,1,0]
]
``` | ### 模拟
根据题意进行模拟。
Java 代码:
```Java
class Solution {
public void setZeroes(int[][] mat) {
int n = mat.length, m = mat[0].length;
boolean[] rows = new boolean[n], cols = new boolean[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mat[i][j] == 0)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.08` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 01.09. 字符串轮转（简单）.md | 面试题 01.09. 字符串轮转 | https://leetcode.cn/problems/string-rotation-lcci/solution/by-ac_oier-2wo1/ | 简单 | [
"字符串哈希"
] | 字符串轮转。给定两个字符串 `s1` 和 `s2`,请编写代码检查 `s2` 是否为 `s1` 旋转而成(比如,`waterbottle` 是 `erbottlewat` 旋转后的字符串)。
示例1:
```
输入:s1 = "waterbottle", s2 = "erbottlewat"
输出:True
```
示例2:
```
输入:s1 = "aa", s2 = "aba"
输出:False
```
提示:
* 字符串长度在 $[0, 100000]$ 范围内。
说明:
你能只调用一次检查子串的方法吗? | ### 字符串哈希
若两字符串互为旋转,则「其一字符串」必然为「另一字符串拓展两倍长度后(循环子串)」的子串。
基于此,我们可以使用「字符串哈希」进行求解:先计算 `s2` 的字符串哈希值 `t`,然后构造出 `s1 + s1` 的哈希数组和次方数组,在两数组中检查是否存在长度为 $n$ 的连续子段的哈希值 `cur` 与 `t` 相等。
**不了解字符串哈希的同学可以看前置🧀 : [字符串哈希入门](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247489813&idx=1&sn=7f3bc18ca390d85b17655f7164d8e660)**
> ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 01.09` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 02.05. 链表求和（中等）.md | 面试题 02.05. 链表求和 | https://leetcode-cn.com/problems/sum-lists-lcci/solution/by-ac_oier-v1zb/ | 中等 | [
"链表",
"模拟"
] | 给定两个用链表表示的整数,每个节点包含一个数位。
这些数位是反向存放的,也就是个位排在链表首部。
编写函数对这两个整数求和,并用链表形式返回结果。
示例:
```
输入:(7 -> 1 -> 6) + (5 -> 9 -> 2),即617 + 295
输出:2 -> 1 -> 9,即912
```
示例:
```
输入:(6 -> 1 -> 7) + (2 -> 9 -> 5),即617 + 295
输出:9 -> 1 -> 2,即912
```
进阶:思考一下,假设这些数位是正向存放的,又该如何解决呢? | ### 链表(反向)
访问链表节点的顺序为「个位、百位、千位 ...」,即与执行「竖式加法」时访问的位数次序一致。
因此我们可以边遍历,边模拟「竖式加法」的过程,使用变量 $t$ 存储进位情况,当 $l1$ 和 $l2$ 没遍历完,或者进位 $t$ 不为 $0$,该计算过程就可以继续,每次使用当前计算结果 `t % 10` 来创建新节点,使用 `t / 10` 来更新进位。
代码:
```Java
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode ans = new ListNode(... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `面试题 02.05. 链表求和` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 03.01. 三合一（简单）.md | 面试题 03.01. 三合一 | https://leetcode-cn.com/problems/three-in-one-lcci/solution/yi-ti-shuang-jie-er-wei-shu-zu-yi-wei-sh-lih7/ | 简单 | [
"栈"
] | 三合一。描述如何只用一个数组来实现三个栈。
你应该实现push(stackNum, value)、pop(stackNum)、isEmpty(stackNum)、peek(stackNum)方法。stackNum表示栈下标,value表示压入的值。
构造函数会传入一个stackSize参数,代表每个栈的大小。
示例1:
```
输入:
["TripleInOne", "push", "push", "pop", "pop", "pop", "isEmpty"]
[[1], [0, 1], [0, 2], [0], [0], [0], [0]]
输出:
[null, null, null, 1, -1, -1, true]
... | ### 二维数组
题目只要求我们使用「一个数组」来实现栈,并没有限制我们使用数组的维度。
因此一个简单的做法是,建立一个二维数组 $data$ 来做。
二维数组的每一行代表一个栈,同时使用一个 $locations$ 记录每个栈「待插入」的下标。
代码:
```java
class TripleInOne {
int N = 3;
// 3 * n 的数组,每一行代表一个栈
int[][] data;
// 记录每个栈「待插入」位置
int[] locations;
public TripleInOne(int stackSize) {
data = ne... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `面试题 03.01. 三合一` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 04.06. 后继者（中等）.md | 面试题 04.06. 后继者 | https://leetcode.cn/problems/successor-lcci/solution/by-ac_oier-xib5/ | 中等 | [
"BST",
"递归"
] | 设计一个算法,找出二叉搜索树中指定节点的 “下一个” 节点(也即中序后继)。
如果指定节点没有对应的 “下一个” 节点,则返回 `null`。
示例 1:
```
输入: root = [2,1,3], p = 1
2
/ \
1 3
输出: 2
```
示例 2:
```
输入: root = [5,3,6,2,4,null,null,1], p = 6
5
/ \
3 6
/ \
2 4
/
1
输出: null
``` | ### BST 特性 + 递归
利用 `BST` 的特性,我们可以根据当前节点 `root` 与 `p` 的值大小关系来确定搜索方向:
1. 若有 `root.val <= p.val` : 根据 `BST` 特性可知当前节点 `root` 及其左子树子节点均满足「值小于等于 `p.val`」,因此不可能是 `p` 点的后继,我们直接到 `root` 的右子树搜索 `p` 的后继(递归处理);
2. 若有 `root.val > p.val` : 当第一次搜索到满足此条件的节点时,在以 `root` 为根节点的子树中「位于最左下方」的值为 `p` 的后继,但也有可能 `root` 没有左子树,因此 `p` 的后继要么在 `roo... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 04.06` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 10.02. 变位词组（中等）.md | 面试题 10.02. 变位词组 | https://leetcode-cn.com/problems/group-anagrams-lcci/solution/gong-shui-san-xie-tong-ji-bian-wei-ci-de-0iqe/ | 中等 | [
"哈希表",
"排序",
"计数",
"数学",
"打表"
] | 编写一种方法,对字符串数组进行排序,将所有变位词组合在一起。变位词是指字母相同,但排列不同的字符串。
注意:本题相对原题稍作修改
示例:
```
输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
输出:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]
```
说明:
* 所有输入均为小写字母。
* 不考虑答案输出的顺序。 | ### 模拟 + 排序
一个朴素的想法是根据题意进行模拟,对每个字符串进行排序作为 `key`,从而实现相同的「变位词」对应同一个 `key`,使用哈希表进行统计即可。
代码:
```Java
class Solution {
public List<List<String>> groupAnagrams(String[] ss) {
List<List<String>> ans = new ArrayList<>();
Map<String, List<String>> map = new HashMap<>();
for (String s : ss) {
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 10.02` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 16.25. LRU 缓存（中等）.md | 面试题 16.25. LRU 缓存 | https://leetcode-cn.com/problems/lru-cache-lcci/solution/gong-shui-san-xie-she-ji-shu-ju-jie-gou-k0iwg/) | 中等 | [
"设计",
"链表",
"哈希表"
] | 运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类:
* LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
* int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
* void put(int key, int value) 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。
进阶:你是否可以在 $O(1)$ 时间复杂度内完成这两种操作?
示... | ### 基本分析
LRU 是一种十分常见的页面置换算法。
将 LRU 翻译成大白话就是:**当不得不淘汰某些数据时(通常是容量已满),选择最久未被使用的数据进行淘汰。**
**题目让我们实现一个容量固定的 `LRUCache` 。如果插入数据时,发现容器已满时,则先按照 LRU 规则淘汰一个数据,再将新数据插入,其中「插入」和「查询」都算作一次“使用”。**
可以通过 🌰 来理解,假设我们有容量为 $2$ 的 `LRUCache` 和 测试键值对 `[`1-1`,`2-2`,`3-3`]` ,将其按照顺序进行插入 & 查询:
* 插入 `1-1`,此时最新的使用数据为 `1-1`
* 插入 `2-2`,此时最新使用数据变为... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 16.25` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.09. 第 k 个数（中等）.md | 面试题 17.09. 第 k 个数 | https://leetcode.cn/problems/get-kth-magic-number-lcci/solution/by-ac_oier-2czm/ | 中等 | [
"优先队列(堆)",
"多路归并",
"双指针"
] | 有些数的素因子只有 `3`,`5`,`7`,请设计一个算法找出第 `k` 个数。注意,不是必须有这些素因子,而是必须不包含其他的素因子。例如,前几个数按顺序应该是 `1`,`3`,`5`,`7`,`9`,`15`,`21`。
示例 1:
```
输入: k = 5
输出: 9
``` | ### 基本分析
本题的基本思路与 [264. 丑数 II : 从朴素优先队列到多路归并](https://mp.weixin.qq.com/s?__biz=MzU4NDE3MTEyMA==&mid=2247490029&idx=1&sn=bba9ddff88d247db310406ee418d5a15) 完全一致。
---
### 优先队列(小根堆)
有了基本的分析思路,一个简单的解法是使用优先队列:
1. 起始先将最小数值 $1$ 放入队列
2. 每次从队列取出最小值 $x$,然后将 $x$ 所对应的数值 $3x$、$5x$ 和 $7x$ 进行入队
3. 对步骤 2 循环多次,第 $k$ 次出队的值即是答案
为了防止... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.09` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.10. 主要元素（简单）.md | 面试题 17.10. 主要元素 | https://leetcode-cn.com/problems/find-majority-element-lcci/solution/gong-shui-san-xie-yi-ti-shuang-jie-ha-xi-zkht/ | 简单 | [
"哈希表",
"摩尔投票"
] | 数组中占比超过一半的元素称之为主要元素。给你一个 整数 数组,找出其中的主要元素。
若没有,返回 -1 。请设计时间复杂度为 $O(N)$ 、空间复杂度为 $O(1)$ 的解决方案。
示例 1:
```
输入:[1,2,5,9,5,9,5,5,5]
输出:5
```
示例 2:
```
输入:[3,2]
输出:-1
```
示例 3:
```
输入:[2,2,1,1,1,2,2]
输出:2
``` | ### 哈希表
一个朴素的做法是使用哈希表进行计数,如果发现某个元素数量超过总数一半,说明找到了答案。
代码:
```Java
class Solution {
public int majorityElement(int[] nums) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
for (int x : nums) {
map.put(x, map.getOrDefault(x, 0) + 1);
if (map.get(x) >... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.10` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.11. 单词距离（中等）.md | 面试题 17.11. 单词距离 | https://leetcode.cn/problems/find-closest-lcci/solution/by-ac_oier-0hv9/ | 中等 | [
"模拟",
"双指针"
] | 有个内含单词的超大文本文件,给定任意两个不同的单词,找出在这个文件中这两个单词的最短距离(相隔单词数)。如果寻找过程在这个文件中会重复多次,而每次寻找的单词不同,你能对此优化吗?
示例:
```
输入:words = ["I","am","a","student","from","a","university","in","a","city"], word1 = "a", word2 = "student"
输出:1
```
提示:
* $words.length <= 100000$ | ### 模拟
对 `words` 进行遍历,使用两个指针 `p` 和 `q` 分别记录最近的两个关键字的位置,并维护更新最小距离。
代码:
```Java
class Solution {
public int findClosest(String[] ws, String a, String b) {
int n = ws.length, ans = n;
for (int i = 0, p = -1, q = -1; i < n; i++) {
String t = ws[i];
if (t.equals(a)) p = i;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.11` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.14. 最小K个数（中等）.md | 面试题 17.14. 最小K个数 | https://leetcode-cn.com/problems/smallest-k-lcci/solution/gong-shui-san-xie-yi-ti-si-jie-you-xian-yy5k5/ | 中等 | [
"优先队列(堆)",
"排序"
] | 设计一个算法,找出数组中最小的 $k$ 个数。以任意顺序返回这k个数均可。
示例:
```
输入: arr = [1,3,5,7,2,4,6,8], k = 4
输出: [1,2,3,4]
```
提示:
* $0 <= len(arr) <= 100000$
* $0 <= k <= \min(100000, len(arr))$ | ### 优先队列(小根堆)
一个直观的想法是使用「优先队列(小根堆)」,起始将所有元素放入堆中,然后再从堆中取出 $k$ 个元素并「顺序」构造答案。
代码:
```Java
class Solution {
public int[] smallestK(int[] arr, int k) {
PriorityQueue<Integer> q = new PriorityQueue<>((a,b)->a-b);
for (int i : arr) q.add(i);
int[] ans = new int[k];
for (int i = 0; i < k; ... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.14` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.19. 消失的两个数字（困难）.md | 面试题 17.19. 消失的两个数字 | https://leetcode.cn/problems/missing-two-lcci/solution/by-ac_oier-pgeh/ | 困难 | [
"数学",
"位运算"
] | 给定一个数组,包含从 `1` 到 `N` 所有的整数,但其中缺了两个数字。你能在 $O(N)$ 时间内只用 $O(1)$ 的空间找到它们吗?
以任意顺序返回这两个数字均可。
示例 1:
```
输入: [1]
输出: [2,3]
```
示例 2:
```
输入: [2,3]
输出: [1,4]
```
提示:
* $nums.length <= 30000$ | ### 数学
根据题意,给定 `nums` 的长度为 $m$ 且缺失了两个数,所有的 $nums[i]$ 加上缺失数字组成连续排列长度为 $n = m + 2$。
根据等差数量求和公式可知,补齐后的排列总和为 $\frac{n \times (1 + n)}{2}$,补全后的理论总和与实际总和之间的差值 $cur = \frac{n \times (1 + n)}{2} - \sum_{i = 0}^{m - 1}nums[i]$ 为缺失数值之和。
根据补全后数值各不相同可知,两者必不可能同时位于 $t = \left \lfloor \frac{cur}{2} \right \rfloor$ 的同一侧(偏大、偏小或数值重复)... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.19` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
LeetCode/面试题/面试题 17.21. 直方图的水量（困难）.md | 面试题 17.21. 直方图的水量 | https://leetcode-cn.com/problems/volume-of-histogram-lcci/solution/gong-shui-san-xie-yi-ti-si-jie-po-su-yu-sqadp/ | 困难 | [
"数学",
"双指针",
"动态规划"
] | 给定一个直方图(也称柱状图),假设有人从上面源源不断地倒水,最后直方图能存多少水量?直方图的宽度为 1。
上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的直方图,在这种情况下,可以接 6 个单位的水(蓝色部分表示水)。 感谢 Marcos 贡献此图。
示例:
```
输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6
``` | ### 朴素解法
对于每根柱子而言,我们只需要找出「其左边最高的柱子」和「其右边最高的柱子」。
对左右的最高柱子取一个最小值,再和当前柱子的高度做一个比较,即可得出当前位置可以接下的雨水。
同时,边缘的柱子不可能接到雨水(某一侧没有柱子)。
这样的做法属于「暴力做法」,但题目没有给数据范围,我们无法分析到底能否 AC。
唯唯诺诺交一个,过了 ~ (好题,建议加入蓝桥杯
代码:
```java []
class Solution {
public int trap(int[] height) {
int n = height.length;
int ans = 0;
... | ### 最后
这是我们「刷穿 LeetCode」系列文章的第 `No.面试题 17.21` 篇,系列开始于 2021/01/01,截止于起始日 LeetCode 上共有 1916 道题目,部分是有锁题,我们将先把所有不带锁的题目刷完。
在这个系列文章里面,除了讲解解题思路以外,还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。
为了方便各位同学能够电脑上进行调试和提交代码,我建立了相关的仓库:https://github.com/SharingSource/LogicStack-LeetCode 。
在仓库地址里,你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.