Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 798a665

Browse files
✨style: Bulk processing format
1 parent 6eb2cfc commit 798a665

31 files changed

+222
-207
lines changed

‎LeetCode/1-10/1. 两数之和(简单).md‎

Lines changed: 16 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -15,25 +15,27 @@ Tag : 「哈希表」、「模拟」
1515
示例 1:
1616
```
1717
输入:nums = [2,7,11,15], target = 9
18+
1819
输出:[0,1]
20+
1921
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
2022
```
2123

2224
示例 2:
2325
```
2426
输入:nums = [3,2,4], target = 6
27+
2528
输出:[1,2]
2629
```
2730

2831
示例 3:
2932
```
3033
输入:nums = [3,3], target = 6
34+
3135
输出:[0,1]
3236
```
3337

34-
3538
提示:
36-
3739
* 2ドル <= nums.length <= 10^3$
3840
* -10ドル^9 <= nums[i] <= 10^9$
3941
* -10ドル^9 <= target <= 10^9$
@@ -45,13 +47,15 @@ Tag : 「哈希表」、「模拟」
4547

4648
由于我们每次要从数组中找两个数。
4749

48-
因此一个很简单的思路是:使用两重循环枚举下标 i 和 j ,分别代表要找的两个数。
50+
因此一个很简单的思路是:使用两重循环枚举下标 $i$ 和 $j$ ,分别代表要找的两个数。
51+
52+
然后判断 $nums[i] + nums[j] = target$ 是否成立。
4953

50-
然后判断 $nums[i] + nums[j] == target$ 是否成立。
54+
另外为了防止得到重复的解,我们需要在第一层循环中让 $i$ 从 0ドル$ 开始,到 $n - 2$ 结束(确保能取到下一位数作为 j );在第二层循环中让 $j$ 从 $i + 1$ 开始,到 $n - 1$ 结束。
5155

52-
另外为了防止得到重复的解,我们需要在第一层循环中让 i 从 0 开始,到 n - 2 结束(确保能取到下一位数作为 j );在第二层循环中让 j 从 i + 1 开始,到 n - 1 结束。
56+
代码:
5357

54-
```Java []
58+
```Java
5559
class Solution {
5660
public int[] twoSum(int[] nums, int t) {
5761
int n = nums.length;
@@ -69,19 +73,20 @@ class Solution {
6973

7074
---
7175

72-
### 哈希表解法
76+
### 哈希表
7377

7478
首先,任何优化的思路都不外乎「减少重复」。
7579

7680
从朴素解法中可以知道,逻辑上我们是先定下来一个数,然后从数组中往后找另外一个值是否存在。但其实我们在找第二个数的过程中是重复扫描了数组多次。
7781

7882
举个例子,对于 `nums = [2,3,8,4], target = 9` 的样例,我们先确定下来第一个数是 `2`,然后从后扫描到最后一个数,检查是否有 `7`。发现没有,再决策第一个数为 `3` 的情况,这时候我们应该利用前一次扫描的结果来帮助我们快速判断是否存在 `6`,而不是再重新进行一次扫描。
7983

80-
这是直观的优化思路,不难想到可以使用哈希表进行存储。以数值为 key,数值的下标为 value。
84+
这是直观的优化思路,不难想到可以使用哈希表进行存储。以数值为 `key`,数值的下标为 `value`。
8185

8286
当动手将想法转化为代码时,会发现如果先敲定第一个数,将后面的数加入哈希表,再进行下一位的遍历的时候,还需要将该数值从哈希表中进行删除。
8387

84-
```Java []
88+
代码:
89+
```Java
8590
class Solution {
8691
public int[] twoSum(int[] nums, int t) {
8792
Map<Integer, Integer> map = new HashMap<>();
@@ -99,9 +104,9 @@ class Solution {
99104

100105
这时候不妨将思路转换过来,遍历过程中敲定第二个数,使用哈希表在第二个数的前面去找第一个数。
101106

102-
具体的做法是,边遍历边存入哈希表,遍历过程中使用的下标 i 用作敲定第二个数,再从现有的哈希表中去找另外一个目标数(由于下标 i 前面的数都被加入哈希表了,即在下标 i 前面去找第一个数)。
107+
具体的做法是,边遍历边存入哈希表,遍历过程中使用的下标 i 用作敲定第二个数,再从现有的哈希表中去找另外一个目标数(由于下标 $i$ 前面的数都被加入哈希表了,即在下标 $i$ 前面去找第一个数)。
103108

104-
```Java []
109+
```Java
105110
class Solution {
106111
public int[] twoSum(int[] nums, int t) {
107112
Map<Integer, Integer> map = new HashMap<>();

‎LeetCode/1-10/10. 正则表达式匹配(困难).md‎

Lines changed: 10 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -6,10 +6,10 @@ Tag : 「动态规划」
66

77

88

9-
给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
9+
给你一个字符串 `s` 和一个字符规律 `p`,请你来实现一个支持 `'.'` 和 `'*'` 的正则表达式匹配。
1010

11-
* '.' 匹配任意单个字符
12-
* '*' 匹配零个或多个前面的那一个元素
11+
* `'.'` 匹配任意单个字符
12+
* `'*'` 匹配零个或多个前面的那一个元素
1313

1414
所谓匹配,是要涵盖 整个 字符串 s的,而不是部分字符串。
1515

@@ -44,11 +44,11 @@ Tag : 「动态规划」
4444
```
4545

4646
提示:
47-
* 0 <= s.length <= 20
48-
* 0 <= p.length <= 30
49-
* s 可能为空,且只包含从 a-z 的小写字母。
50-
* p 可能为空,且只包含从 a-z 的小写字母,以及字符 . 和 *。
51-
* 保证每次出现字符 * 时,前面都匹配到有效的字符
47+
* $0 <= s.length <= 20$
48+
* $0 <= p.length <= 30$
49+
* `s` 可能为空,且只包含从 `a-z` 的小写字母。
50+
* `p` 可能为空,且只包含从 `a-z` 的小写字母,以及字符 `.` 和 `*`。
51+
* 保证每次出现字符 `*` 时,前面都匹配到有效的字符
5252

5353
---
5454

@@ -119,12 +119,11 @@ class Solution {
119119
}
120120
}
121121
```
122-
* 时间复杂度:n 表示 s 的长度,m 表示 p 的长度,总共 $n * m$ 个状态。复杂度为 $O(n * m)$
123-
* 空间复杂度:使用了二维数组记录结果。复杂度为 $O(n * m)$
122+
* 时间复杂度:$n$ 表示 `s` 的长度,$m$ 表示 `p` 的长度,总共 $n \times m$ 个状态。复杂度为 $O(n \times m)$
123+
* 空间复杂度:使用了二维数组记录结果。复杂度为 $O(n \times m)$
124124

125125
**动态规划本质上是枚举(不重复的暴力枚举),因此其复杂度很好分析,有多少个状态就要被计算多少次,复杂度就为多少。**
126126

127-
128127
---
129128

130129
### 最后

‎LeetCode/1-10/2. 两数相加(中等).md‎

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,32 +10,36 @@ Tag : 「递归」、「链表」、「数学」、「模拟」
1010

1111
请你将两个数相加,并以相同形式返回一个表示和的链表。
1212

13-
你可以假设除了数字 0 之外,这两个数都不会以 0 开头。
13+
你可以假设除了数字 0ドル$ 之外,这两个数都不会以 0ドル$ 开头。
1414

1515
示例 1:
1616

1717
![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/01/02/addtwonumber1.jpg)
1818

1919
```
2020
输入:l1 = [2,4,3], l2 = [5,6,4]
21+
2122
输出:[7,0,8]
23+
2224
解释:342 + 465 = 807.
2325
```
2426
示例 2:
2527
```
2628
输入:l1 = [0], l2 = [0]
29+
2730
输出:[0]
2831
```
2932
示例 3:
3033
```
3134
输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
35+
3236
输出:[8,9,9,9,0,0,0,1]
3337
```
3438

3539
提示:
3640

37-
* 每个链表中的节点数在范围 [1, 100] 内
38-
* 0 <= Node.val <= 9
41+
* 每个链表中的节点数在范围 $[1, 100]$ 内
42+
* $0 <= Node.val <= 9$
3943
* 题目数据保证列表表示的数字不含前导零
4044

4145

@@ -45,7 +49,7 @@ Tag : 「递归」、「链表」、「数学」、「模拟」
4549

4650
这是道模拟题,模拟人工竖式做加法的过程:
4751

48-
从最低位至最高位,逐位相加,如果和大于等于 10,则保留个位数字,同时向前一位进 1 如果最高位有进位,则需在最前面补 1。
52+
从最低位至最高位,逐位相加,如果和大于等于 10ドル$,则保留个位数字,同时向前一位进 1 如果最高位有进位,则需在最前面补 1ドル$。
4953

5054
做有关链表的题目,有个常用技巧:添加一个虚拟头结点(哨兵),帮助简化边界情况的判断。
5155

‎LeetCode/1-10/3. 无重复字符的最长子串(中等).md‎

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,32 +11,39 @@ Tag : 「哈希表」、「双指针」、「滑动窗口」
1111
示例 1:
1212
```
1313
输入: s = "abcabcbb"
14+
1415
输出: 3
16+
1517
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
1618
```
1719
示例 2:
1820
```
1921
输入: s = "bbbbb"
22+
2023
输出: 1
24+
2125
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
2226
```
2327
示例 3:
2428
```
2529
输入: s = "pwwkew"
30+
2631
输出: 3
32+
2733
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
2834
请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
2935
```
3036
示例 4:
3137
```
3238
输入: s = ""
39+
3340
输出: 0
3441
```
3542

3643
提示:
3744

38-
* 0 <= s.length <= 5 * $10^4$
39-
* s 由英文字母、数字、符号和空格组成
45+
* $0 <= s.length <= 5 \times 10^4$
46+
* `s` 由英文字母、数字、符号和空格组成
4047

4148
---
4249

‎LeetCode/1-10/4. 寻找两个正序数组的中位数(困难).md‎

Lines changed: 18 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -6,48 +6,55 @@ Tag : 「二分」、「分治」
66

77

88

9-
给定两个大小分别为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。
9+
给定两个大小分别为 $m$ 和 $n$ 的正序(从小到大)数组 `nums1` 和 `nums2`。
1010

1111
请你找出并返回这两个正序数组的「中位数」。
1212

1313
示例 1:
1414
```
1515
输入:nums1 = [1,3], nums2 = [2]
16+
1617
输出:2.00000
18+
1719
解释:合并数组 = [1,2,3] ,中位数 2
1820
```
1921
示例 2:
2022
```
2123
输入:nums1 = [1,2], nums2 = [3,4]
24+
2225
输出:2.50000
26+
2327
解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5
2428
```
2529
示例 3:
2630
```
2731
输入:nums1 = [0,0], nums2 = [0,0]
32+
2833
输出:0.00000
2934
```
3035
示例 4:
3136
```
3237
输入:nums1 = [], nums2 = [1]
38+
3339
输出:1.00000
3440
```
3541
示例 5:
3642
```
3743
输入:nums1 = [2], nums2 = []
44+
3845
输出:2.00000
3946
```
4047

4148
提示:
42-
* nums1.length == m
43-
* nums2.length == n
44-
* 0 <= m <= 1000
45-
* 0 <= n <= 1000
46-
* 1 <= m + n <= 2000
47-
* -$10^6$ <= nums1[i], nums2[i] <= $10^6$
49+
* $nums1.length == m$
50+
* $nums2.length == n$
51+
* $0 <= m <= 1000$
52+
* $0 <= n <= 1000$
53+
* $1 <= m + n <= 2000$
54+
* $-10^6 <= nums1[i], nums2[i] <= 10^6$
4855

4956

50-
进阶:你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗?
57+
进阶:你能设计一个时间复杂度为 $O(\log (m+n))$ 的算法解决此问题吗?
5158

5259
---
5360

@@ -143,14 +150,11 @@ class Solution {
143150
3. 根据数据规模,判断我们的朴素算法计算机是否可以在 1s 内处理完 2 ,即判断运算次数是否在 10ドル^7$ 以内 3 。例如本题使用双指针算法,指针移动和判断大小算一次运行,由于数据只有 2000,距离 10ドル^7$ 还很远,所以完全足够了
144151

145152

153+
说明 1:正规的算法题目都会提供数据规模,LeetCode 上一些旧题目没有提供,是因为当时出的时候不太规范,LeetCode 新题、其他 OJ 平台题目,算法竞赛题目都会有。
146154

147-
*说明 1:正规的算法题目都会提供数据规模,LeetCode 上一些旧题目没有提供,是因为当时出的时候不太规范,LeetCode 新题、其他 OJ 平台题目,算法竞赛题目都会有。*
148-
149-
*说明 2:即使是最严格的 OJ 中最简单的题目,也会提供 1s 的运行时间,超过这个时间才算超时。*
150-
151-
*说明 3:计算器 1s 内极限的处理速度是 10ドル^8$ ,但为了尽可能不出现错误提交,使用技巧时尽量和 10ドル^7$ 进行比较。*
152-
155+
说明 2:即使是最严格的 OJ 中最简单的题目,也会提供 1s 的运行时间,超过这个时间才算超时。
153156

157+
说明 3:计算器 1s 内极限的处理速度是 10ドル^8$ ,但为了尽可能不出现错误提交,使用技巧时尽量和 10ドル^7$ 进行比较。
154158

155159
**注意:这两个技巧,我只推荐在机试或者竞赛(尽可能快 AC 的场景)中使用。平时练习或者和面试的时候必须老实按照题目要求来。**
156160

‎LeetCode/1-10/5. 最长回文子串(中等).md‎

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ Tag : 「模拟」、「回文串」
66

77

88

9-
给你一个字符串 s,找到 s 中最长的回文子串。
9+
给你一个字符串 `s`,找到 `s` 中最长的回文子串。
1010

1111
示例 1:
1212
```
@@ -32,8 +32,8 @@ Tag : 「模拟」、「回文串」
3232

3333
提示:
3434

35-
* 1 <= s.length <= 1000
36-
* s 仅由数字和英文字母(大写和/或小写)组成
35+
* $1 <= s.length <= 1000$
36+
* `s` 仅由数字和英文字母(大写和/或小写)组成
3737

3838

3939
---
@@ -166,8 +166,6 @@ class Solution {
166166

167167
对于想要背过 Manacher 算法的同学,建议先敲 3 遍,默写 2 遍,然后过了 24 小时,再默写 2 遍,一周后,再进行重复,直到熟练。
168168

169-
不要害怕遗忘,遗忘是正常的,多进行几次重复便会形成肌肉记忆。LeetCode 周赛上常年占据第一页的选手,无不都是对算法套路和模板极其熟练。加油 ~
170-
171169
---
172170
### 最后
173171

‎LeetCode/1-10/6. Z 字形变换(中等).md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -94,7 +94,7 @@ class Solution {
9494
}
9595
```
9696
* 时间复杂度:创建数组的工作只会发生一次,清空 `idxs` 数组操作会发生在每个样例中,复杂度为 $O(m)$;将 `s` 的每个字符填入矩阵的复杂度为 $O(n)$;从矩阵中取出字符构建答案复杂度为 $O(n)$。整体复杂度为 $O(m + n)$
97-
* 空间复杂度:$O(n * m)$
97+
* 空间复杂度:$O(n \times m)$
9898

9999
---
100100

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /