Skip to content

Commit 86f4318

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lcof2 problem: No.078.Merge K Sorted Lists
1 parent c5df5c4 commit 86f4318

File tree

13 files changed

+604
-61
lines changed

13 files changed

+604
-61
lines changed

‎lcof2/剑指 Offer II 078. 合并排序链表/README.md

+285-1
Original file line numberDiff line numberDiff line change
@@ -61,22 +61,306 @@
6161

6262
<!-- 这里可写通用的实现逻辑 -->
6363

64+
合并前后两个链表，结果放在后一个链表位置上，依次循环下去。最后返回链表数组的最后一个元素。
65+
6466
<!-- tabs:start -->
6567

6668
### **Python3**
6769

6870
<!-- 这里可写当前语言的特殊实现逻辑 -->
6971

7072
```python
71-
73+
# Definition for singly-linked list.
74+
# class ListNode:
75+
# def __init__(self, val=0, next=None):
76+
# self.val = val
77+
# self.next = next
78+
class Solution:
79+
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
80+
n = len(lists)
81+
if n == 0:
82+
return None
83+
for i in range(n - 1):
84+
lists[i + 1] = self.mergeTwoLists(lists[i], lists[i + 1])
85+
return lists[-1]
86+
87+
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
88+
dummy = ListNode()
89+
cur = dummy
90+
while l1 and l2:
91+
if l1.val <= l2.val:
92+
cur.next = l1
93+
l1 = l1.next
94+
else:
95+
cur.next = l2
96+
l2 = l2.next
97+
cur = cur.next
98+
cur.next = l1 or l2
99+
return dummy.next
72100
```
73101

74102
### **Java**
75103

76104
<!-- 这里可写当前语言的特殊实现逻辑 -->
77105

78106
```java
107+
/**
108+
* Definition for singly-linked list.
109+
* public class ListNode {
110+
* int val;
111+
* ListNode next;
112+
* ListNode() {}
113+
* ListNode(int val) { this.val = val; }
114+
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
115+
* }
116+
*/
117+
class Solution {
118+
public ListNode mergeKLists(ListNode[] lists) {
119+
int n = lists.length;
120+
if (n == 0) {
121+
return null;
122+
}
123+
for (int i = 0; i < n - 1; ++i) {
124+
lists[i + 1] = mergeLists(lists[i], lists[i + 1]);
125+
}
126+
return lists[n - 1];
127+
}
128+
129+
private ListNode mergeLists(ListNode l1, ListNode l2) {
130+
ListNode dummy = new ListNode();
131+
ListNode cur = dummy;
132+
while (l1 != null && l2 != null) {
133+
if (l1.val <= l2.val) {
134+
cur.next = l1;
135+
l1 = l1.next;
136+
} else {
137+
cur.next = l2;
138+
l2 = l2.next;
139+
}
140+
cur = cur.next;
141+
}
142+
cur.next = l1 == null ? l2 : l1;
143+
return dummy.next;
144+
}
145+
}
146+
```
147+
148+
### **C++**
149+
150+
```cpp
151+
/**
152+
* Definition for singly-linked list.
153+
* struct ListNode {
154+
* int val;
155+
* ListNode *next;
156+
* ListNode() : val(0), next(nullptr) {}
157+
* ListNode(int x) : val(x), next(nullptr) {}
158+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
159+
* };
160+
*/
161+
class Solution {
162+
public:
163+
ListNode* mergeKLists(vector<ListNode*>& lists) {
164+
int n = lists.size();
165+
if (n == 0) return nullptr;
166+
for (int i = 1; i < n; ++i) lists[i] = mergeTwoLists(lists[i - 1], lists[i]);
167+
return lists[n - 1];
168+
}
169+
170+
private:
171+
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
172+
ListNode* dummy = new ListNode();
173+
ListNode* cur = dummy;
174+
while (l1 && l2)
175+
{
176+
if (l1->val <= l2->val)
177+
{
178+
cur->next = l1;
179+
l1 = l1->next;
180+
}
181+
else
182+
{
183+
cur->next = l2;
184+
l2 = l2->next;
185+
}
186+
cur = cur->next;
187+
}
188+
cur->next = l1 ? l1 : l2;
189+
return dummy->next;
190+
}
191+
};
192+
```
193+
194+
### **Go**
195+
196+
```go
197+
/**
198+
* Definition for singly-linked list.
199+
* type ListNode struct {
200+
* Val int
201+
* Next *ListNode
202+
* }
203+
*/
204+
func mergeKLists(lists []*ListNode) *ListNode {
205+
n := len(lists)
206+
if n == 0 {
207+
return nil
208+
}
209+
for i := 1; i < n; i++ {
210+
lists[i] = mergeTwoLists(lists[i-1], lists[i])
211+
}
212+
return lists[n-1]
213+
}
214+
215+
func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
216+
dummy := &ListNode{}
217+
cur := dummy
218+
for l1 != nil && l2 != nil {
219+
if l1.Val <= l2.Val {
220+
cur.Next = l1
221+
l1 = l1.Next
222+
} else {
223+
cur.Next = l2
224+
l2 = l2.Next
225+
}
226+
cur = cur.Next
227+
}
228+
if l1 != nil {
229+
cur.Next = l1
230+
} else if l2 != nil {
231+
cur.Next = l2
232+
}
233+
return dummy.Next
234+
}
235+
```
236+
237+
### **JavaScript**
238+
239+
```js
240+
/**
241+
* Definition for singly-linked list.
242+
* function ListNode(val, next) {
243+
* this.val = (val===undefined ? 0 : val)
244+
* this.next = (next===undefined ? null : next)
245+
* }
246+
*/
247+
/**
248+
* @param {ListNode[]} lists
249+
* @return {ListNode}
250+
*/
251+
var mergeKLists = function(lists) {
252+
const n = lists.length;
253+
if (n == 0) {
254+
return null;
255+
}
256+
for (let i = 1; i < n; ++i) {
257+
lists[i] = mergeTwoLists(lists[i - 1], lists[i]);
258+
}
259+
return lists[n - 1];
260+
};
261+
262+
function mergeTwoLists(l1, l2) {
263+
const dummy = new ListNode();
264+
let cur = dummy;
265+
while (l1 && l2) {
266+
if (l1.val <= l2.val) {
267+
cur.next = l1;
268+
l1 = l1.next;
269+
} else {
270+
cur.next = l2;
271+
l2 = l2.next;
272+
}
273+
cur = cur.next;
274+
}
275+
cur.next = l1 || l2;
276+
return dummy.next;
277+
}
278+
```
279+
280+
### **Ruby**
281+
282+
```rb
283+
# Definition for singly-linked list.
284+
# class ListNode
285+
# attr_accessor :val, :next
286+
# def initialize(val = 0, _next = nil)
287+
# @val = val
288+
# @next = _next
289+
# end
290+
# end
291+
# @param {ListNode[]} lists
292+
# @return {ListNode}
293+
def merge_k_lists(lists)
294+
n = lists.length
295+
i = 1
296+
while i < n
297+
lists[i] = merge_two_lists(lists[i - 1], lists[i])
298+
i += 1
299+
end
300+
lists[n - 1]
301+
end
302+
303+
def merge_two_lists(l1, l2)
304+
dummy = ListNode.new()
305+
cur = dummy
306+
while l1 && l2
307+
if l1.val <= l2.val
308+
cur.next = l1
309+
l1 = l1.next
310+
else
311+
cur.next = l2
312+
l2 = l2.next
313+
end
314+
cur = cur.next
315+
end
316+
cur.next = l1 || l2
317+
dummy.next
318+
end
319+
```
79320

321+
### **C#**
322+
323+
```cs
324+
/**
325+
* Definition for singly-linked list.
326+
* public class ListNode {
327+
* public int val;
328+
* public ListNode next;
329+
* public ListNode(int val=0, ListNode next=null) {
330+
* this.val = val;
331+
* this.next = next;
332+
* }
333+
* }
334+
*/
335+
public class Solution {
336+
public ListNode MergeKLists(ListNode[] lists) {
337+
int n = lists.Length;
338+
if (n == 0) {
339+
return null;
340+
}
341+
for (int i = 1; i < n; ++i) {
342+
lists[i] = MergeTwoLists(lists[i - 1], lists[i]);
343+
}
344+
return lists[n - 1];
345+
}
346+
347+
private ListNode MergeTwoLists(ListNode l1, ListNode l2) {
348+
ListNode dummy = new ListNode();
349+
ListNode cur = dummy;
350+
while (l1 != null && l2 != null) {
351+
if (l1.val <= l2.val) {
352+
cur.next = l1;
353+
l1 = l1.next;
354+
} else {
355+
cur.next = l2;
356+
l2 = l2.next;
357+
}
358+
cur = cur.next;
359+
}
360+
cur.next = l1 == null ? l2 : l1;
361+
return dummy.next;
362+
}
363+
}
80364
```
81365

82366
### **...**

‎lcof2/剑指 Offer II 078. 合并排序链表/Solution.cpp

+41
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* struct ListNode {
4+
* int val;
5+
* ListNode *next;
6+
* ListNode() : val(0), next(nullptr) {}
7+
* ListNode(int x) : val(x), next(nullptr) {}
8+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
9+
* };
10+
*/
11+
class Solution {
12+
public:
13+
ListNode* mergeKLists(vector<ListNode*>& lists) {
14+
int n = lists.size();
15+
if (n == 0) return nullptr;
16+
for (int i = 1; i < n; ++i) lists[i] = mergeTwoLists(lists[i - 1], lists[i]);
17+
return lists[n - 1];
18+
}
19+
20+
private:
21+
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
22+
ListNode* dummy = new ListNode();
23+
ListNode* cur = dummy;
24+
while (l1 && l2)
25+
{
26+
if (l1->val <= l2->val)
27+
{
28+
cur->next = l1;
29+
l1 = l1->next;
30+
}
31+
else
32+
{
33+
cur->next = l2;
34+
l2 = l2->next;
35+
}
36+
cur = cur->next;
37+
}
38+
cur->next = l1 ? l1 : l2;
39+
return dummy->next;
40+
}
41+
};

‎lcof2/剑指 Offer II 078. 合并排序链表/Solution.cs

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* public class ListNode {
4+
* public int val;
5+
* public ListNode next;
6+
* public ListNode(int val=0, ListNode next=null) {
7+
* this.val = val;
8+
* this.next = next;
9+
* }
10+
* }
11+
*/
12+
public class Solution {
13+
public ListNode MergeKLists(ListNode[] lists) {
14+
int n = lists.Length;
15+
if (n == 0) {
16+
return null;
17+
}
18+
for (int i = 1; i < n; ++i) {
19+
lists[i] = MergeTwoLists(lists[i - 1], lists[i]);
20+
}
21+
return lists[n - 1];
22+
}
23+
24+
private ListNode MergeTwoLists(ListNode l1, ListNode l2) {
25+
ListNode dummy = new ListNode();
26+
ListNode cur = dummy;
27+
while (l1 != null && l2 != null) {
28+
if (l1.val <= l2.val) {
29+
cur.next = l1;
30+
l1 = l1.next;
31+
} else {
32+
cur.next = l2;
33+
l2 = l2.next;
34+
}
35+
cur = cur.next;
36+
}
37+
cur.next = l1 == null ? l2 : l1;
38+
return dummy.next;
39+
}
40+
}

0 commit comments

Comments
 (0)