Skip to content

Commit b8d8e66

Browse files
itchargeitcharge
committed
更新题解列表
1 parent ddb9df1 commit b8d8e66

8 files changed

+144
-26
lines changed

‎Solutions/0023. 合并K个升序链表.md‎

Lines changed: 43 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,15 +5,50 @@
55

66
## 题目大意
77

8-
给定一个链表数组，每个链表都已经按照升序排列。
8+
**描述**：给定一个链表数组，每个链表都已经按照升序排列。
99

10-
要求：将所有链表合并到一个升序链表中，返回合并后的链表。
10+
**要求**：将所有链表合并到一个升序链表中，返回合并后的链表。
11+
12+
**说明**：
13+
14+
- $k == lists.length$。
15+
- $0 \le k \le 10^4$。
16+
- $0 \le lists[i].length \le 500$。
17+
- $-10^4 \le lists[i][j] \le 10^4$。
18+
- $lists[i]$ 按升序排列。
19+
- $lists[i].length$ 的总和不超过 $10^4$。
20+
21+
**示例**：
22+
23+
- 示例 1：
24+
25+
```Python
26+
输入：lists = [[1,4,5],[1,3,4],[2,6]]
27+
输出：[1,1,2,3,4,4,5,6]
28+
解释：链表数组如下：
29+
[
30+
1->4->5,
31+
1->3->4,
32+
2->6
33+
]
34+
将它们合并到一个有序链表中得到。
35+
1->1->2->3->4->4->5->6
36+
```
37+
38+
- 示例 2：
39+
40+
```Python
41+
输入：lists = []
42+
输出：[]
43+
```
1144

1245
## 解题思路
1346

47+
### 思路 1：分治
48+
1449
分而治之的思想。将链表数组不断二分，转为规模为二分之一的子问题，然后再进行归并排序。
1550

16-
## 代码
51+
### 思路 1：代码
1752

1853
```Python
1954
class Solution:
@@ -49,3 +84,8 @@ class Solution:
4984
return self.merge_sort(lists, 0, size - 1)
5085
```
5186

87+
### 思路 1：复杂度分析
88+
89+
- **时间复杂度**：$O(k \times n \times \log_2k)$。
90+
- **空间复杂度**：$O(\log_2k)$。
91+

‎Solutions/0025. K 个一组翻转链表.md‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@
5959
6. 最后等到 `cur` 遍历到链表末尾（即 `cur == tail`）时，令「当前待反转区间的第一个节点的前一个节点」指向「反转区间后的头节点」 ，即 `head.next = pre`。令「待反转区间的第一个节点（反转之后为区间的尾节点）」指向「待反转分区间的最后一个节点的后一个节点」，即 `first.next = tail`。
6060
7. 最后返回新的头节点 `dummy_head.next`。
6161

62-
### 思路 1：迭代代码
62+
### 思路 1：代码
6363

6464
```Python
6565
# Definition for singly-linked list.
@@ -96,3 +96,8 @@ class Solution:
9696
tail = tail.next
9797
return dummy_head.next
9898
```
99+
100+
### 思路 1：复杂度分析
101+
102+
- **时间复杂度**：$O(n)$。其中 $n$ 为链表的总长度。
103+
- **空间复杂度**：$O(1)$。

‎Solutions/0092. 反转链表 II.md‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,11 @@ class Solution:
8383
return dummy_head.next
8484
```
8585

86+
### 思路 1：复杂度分析
87+
88+
- **时间复杂度**：$O(n)$。其中 $n$ 是链表节点个数。
89+
- **空间复杂度**：$O(1)$。
90+
8691
## 参考资料
8792

8893
- 【题解】[动画图解：翻转链表的指定区间 - 反转链表 II - 力扣](https://leetcode.cn/problems/reverse-linked-list-ii/solution/dong-hua-tu-jie-fan-zhuan-lian-biao-de-z-n4px/)

‎Solutions/0143. 重排链表.md‎

Lines changed: 34 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5,17 +5,41 @@
55

66
## 题目大意
77

8-
给定一个单链表 `L` 的头节点 `head`，单链表 `L` 表示为：$L_0$ -> $L_1$ -> $L_2$ -> ... -> $L_{n-1}$ -> $L_n$。
8+
**描述**：给定一个单链表 `L` 的头节点 `head`，单链表 `L` 表示为：$L_0$ -> $L_1$ -> $L_2$ -> ... -> $L_{n-1}$ -> $L_n$。
99

10-
要求：将单链表 `L` 重新排列为：$L_0$ -> $L_n$ -> $L_1$ -> $L_{n-1}$ -> $L_2$ -> $L_{n-2}$ -> $L_3$ -> $L_{n-3}$ -> ...。
10+
**要求**：将单链表 `L` 重新排列为：$L_0$ -> $L_n$ -> $L_1$ -> $L_{n-1}$ -> $L_2$ -> $L_{n-2}$ -> $L_3$ -> $L_{n-3}$ -> ...。
1111

12-
注意：需要将实际节点进行交换。
12+
**说明**：
13+
14+
- 需要将实际节点进行交换。
15+
16+
**示例**：
17+
18+
- 示例 1：
19+
20+
![](https://pic.leetcode-cn.com/1626420311-PkUiGI-image.png)
21+
22+
```Python
23+
输入：head = [1,2,3,4]
24+
输出：[1,4,2,3]
25+
```
26+
27+
- 示例 2：
28+
29+
![](https://pic.leetcode-cn.com/1626420320-YUiulT-image.png)
30+
31+
```Python
32+
输入：head = [1,2,3,4,5]
33+
输出：[1,5,2,4,3]
34+
```
1335

1436
## 解题思路
1537

16-
链表不能像数组那样直接进行随机访问。所以我们可以先将链表转为线性表。然后直接按照提要要求的排列顺序访问对应数据元素，重新建立链表。
38+
### 思路 1：线性表
1739

18-
## 代码
40+
因为链表无法像数组那样直接进行随机访问。所以我们可以先将链表转为线性表，然后直接按照提要要求的排列顺序访问对应数据元素，重新建立链表。
41+
42+
### 思路 1：代码
1943

2044
```Python
2145
class Solution:
@@ -43,3 +67,8 @@ class Solution:
4367
vec[left].next = None
4468
```
4569

70+
### 思路 1：复杂度分析
71+
72+
- **时间复杂度**：$O(n)$。
73+
- **空间复杂度**：$O(n)$。
74+

‎Solutions/0160. 相交链表.md‎

Lines changed: 50 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -5,33 +5,67 @@
55

66
## 题目大意
77

8-
给定 A、B 两个链表，判断两个链表是否相交，返回相交的起始点。如果不相交，则返回 None。
8+
**描述**：给定 `listA`、`listB` 两个链表。
99

10-
比如：链表 A 为 [4, 1, 8, 4, 5]，链表 B 为 [5, 0, 1, 8, 4, 5]。则如下图所示，两个链表相交的起始节点为 8，则输出结果为 8。
10+
**要求**：判断两个链表是否相交，返回相交的起始点。如果不相交，则返回 `None`。
11+
12+
**说明**：
13+
14+
- `listA` 中节点数目为 $m$。
15+
- `listB` 中节点数目为 $n$。
16+
- $1 \le m, n \le 3 * 10^4$。
17+
- $1 \le Node.val \le 10^5$。
18+
- $0 \le skipA \le m$。
19+
- $0 \le skipB \le n$。
20+
- 如果 `listA` 和 `listB` 没有交点，`intersectVal` 为 $0$。
21+
- 如果 `listA` 和 `listB` 有交点，`intersectVal == listA[skipA] == listB[skipB]`。
22+
23+
**示例**：
24+
25+
- 示例 1：
1126

1227
![](https://assets.leetcode.com/uploads/2018/12/13/160_example_1.png)
1328

29+
```Python
30+
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
31+
输出：Intersected at '8'
32+
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
33+
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
34+
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
35+
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。
36+
```
1437

38+
- 示例 2：
1539

40+
![](https://assets.leetcode.com/uploads/2021/03/05/160_example_2.png)
1641

42+
```Python
43+
输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
44+
输出：Intersected at '2'
45+
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
46+
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
47+
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
48+
```
1749

1850
## 解题思路
1951

20-
如果两个链表相交，那么从相交位置开始，到结束，必有一段等长且相同的节点。假设链表 A 的长度为 m、链表 B 的长度为 n，他们的相交序列有 k 个，则相交情况可以如下如所示：
52+
### 思路 1：双指针
53+
54+
如果两个链表相交，那么从相交位置开始，到结束，必有一段等长且相同的节点。假设链表 `listA` 的长度为 $m$、链表 `listB` 的长度为 $n$，他们的相交序列有 $k$ 个，则相交情况可以如下如所示：
2155

22-
![](http://qncdn.bujige.net/images/20210401113538.png)
56+
![](https://qcdn.itcharge.cn/images/20210401113538.png)
2357

24-
现在问题是如何找到 m-k 或者 n-k 的位置。
58+
现在问题是如何找到 $m - k$ 或者 $n - k$ 的位置。
2559

26-
考虑将链表 A 的末尾拼接上链表 B，链表 B 的末尾拼接上链表 A。
60+
考虑将链表 `listA` 的末尾拼接上链表 `listB`，链表 `listB` 的末尾拼接上链表 `listA`。
2761

28-
然后使用两个指针 pA 、PB，分别从链表 A、链表 B 的头节点开始遍历，如果走到共同的节点，则返回该节点。
62+
然后使用两个指针 `pA` 、`pB`，分别从链表 `listA`、链表 `listB` 的头节点开始遍历，如果走到共同的节点，则返回该节点。
2963

30-
否则走到两个链表末尾，返回 None。
64+
否则走到两个链表末尾，返回 `None`。
3165

32-
![image-20210401114058127](http://qncdn.bujige.net/images/20210401114100.png)
66+
![](https://qcdn.itcharge.cn/images/20210401114100.png)
3367

34-
## 代码
68+
### 思路 1：代码
3569

3670
```Python
3771
class Solution:
@@ -40,9 +74,14 @@ class Solution:
4074
return None
4175
pA = headA
4276
pB = headB
43-
while pA != pB :
77+
while pA != pB:
4478
pA = pA.next if pA != None else headB
4579
pB = pB.next if pB != None else headA
4680
return pA
4781
```
4882

83+
### 思路 1：复杂度分析
84+
85+
- **时间复杂度**：$O(m + n)$。
86+
- **空间复杂度**：$O(1)$。
87+

‎Solutions/剑指 Offer 52. 两个链表的第一个公共节点.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@
1515

1616
如果两个链表相交，那么从相交位置开始，到结束，必有一段等长且相同的节点。假设链表 A 的长度为 m、链表 B 的长度为 n，他们的相交序列有 k 个，则相交情况可以如下如所示：
1717

18-
![](http://qncdn.bujige.net/images/20210401113538.png)
18+
![](https://qcdn.itcharge.cn/images/20210401113538.png)
1919

2020
现在问题是如何找到 m-k 或者 n-k 的位置。
2121

@@ -25,7 +25,7 @@
2525

2626
否则走到两个链表末尾，返回 None。
2727

28-
![image-20210401114058127](http://qncdn.bujige.net/images/20210401114100.png)
28+
![](https://qcdn.itcharge.cn/images/20210401114100.png)
2929

3030
## 代码
3131

‎Solutions/剑指 Offer II 023. 两个链表的第一个重合节点.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@
1919

2020
如果两个链表相交，那么从相交位置开始，到结束，必有一段等长且相同的节点。假设链表 A 的长度为 m、链表 B 的长度为 n，他们的相交序列有 k 个，则相交情况可以如下如所示：
2121

22-
![](http://qncdn.bujige.net/images/20210401113538.png)
22+
![](https://qcdn.itcharge.cn/images/20210401113538.png)
2323

2424
现在问题是如何找到 m-k 或者 n-k 的位置。
2525

@@ -29,7 +29,7 @@
2929

3030
否则走到两个链表末尾，返回 None。
3131

32-
![image-20210401114058127](http://qncdn.bujige.net/images/20210401114100.png)
32+
![](https://qcdn.itcharge.cn/images/20210401114100.png)
3333

3434
## 代码
3535

‎Solutions/面试题 02.07. 链表相交.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@
2121

2222
如果两个链表相交，那么从相交位置开始，到结束，必有一段等长且相同的节点。假设链表 `A` 的长度为 `m`、链表 `B` 的长度为 `n`，他们的相交序列有 `k` 个，则相交情况可以如下如所示：
2323

24-
![](http://qncdn.bujige.net/images/20210401113538.png)
24+
![](https://qcdn.itcharge.cn/images/20210401113538.png)
2525

2626
现在问题是如何找到 `m - k` 或者 `n - k` 的位置。
2727

@@ -31,7 +31,7 @@
3131

3232
否则走到两个链表末尾，返回 `None`。
3333

34-
![image-20210401114058127](http://qncdn.bujige.net/images/20210401114100.png)
34+
![](https://qcdn.itcharge.cn/images/20210401114100.png)
3535

3636
## 代码
3737

0 commit comments

Comments
 (0)