Skip to content

Commit c6d87b0

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0023
No.0023.Merge k Sorted Lists
1 parent a920c3b commit c6d87b0

File tree

4 files changed

+331
-0
lines changed

4 files changed

+331
-0
lines changed

‎solution/0000-0099/0023.Merge k Sorted Lists/README.md

Lines changed: 119 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -55,8 +55,16 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
**朴素解法：**
59+
5860
合并前后两个链表，结果放在后一个链表位置上，依次循环下去。最后返回链表数组的最后一个元素。
5961

62+
**分而治之：**
63+
64+
多个链表合并复杂，若只有两个或一个链表时，那么就如同 [21. 合并两个有序链表](https://leetcode-cn.com/problems/merge-two-sorted-lists/) 一样。
65+
66+
与归并排序同思路，不断拆散，最终合并即可。
67+
6068
<!-- tabs:start -->
6169

6270
### **Python3**
@@ -357,6 +365,117 @@ public class Solution {
357365
}
358366
```
359367

368+
### **TypeScript**
369+
370+
```ts
371+
/**
372+
* Definition for singly-linked list.
373+
* class ListNode {
374+
* val: number
375+
* next: ListNode | null
376+
* constructor(val?: number, next?: ListNode | null) {
377+
* this.val = (val===undefined ? 0 : val)
378+
* this.next = (next===undefined ? null : next)
379+
* }
380+
* }
381+
*/
382+
383+
function mergeKLists(lists: Array<ListNode | null>): ListNode | null {
384+
const n = lists.length;
385+
const dfs = (start: number, end: number) => {
386+
if (end - start <= 1) {
387+
return lists[start] ?? null;
388+
}
389+
390+
const mid = (start + end) >> 1;
391+
let left = dfs(start, mid);
392+
let right = dfs(mid, end);
393+
394+
const dummy = new ListNode();
395+
let cur = dummy;
396+
while (left || right) {
397+
let next: ListNode;
398+
if (
399+
(left ?? { val: Infinity }).val <
400+
(right ?? { val: Infinity }).val
401+
) {
402+
next = left;
403+
left = left.next;
404+
} else {
405+
next = right;
406+
right = right.next;
407+
}
408+
cur.next = next;
409+
cur = next;
410+
}
411+
return dummy.next;
412+
};
413+
return dfs(0, n);
414+
}
415+
```
416+
417+
### **Rust**
418+
419+
```rust
420+
// Definition for singly-linked list.
421+
// #[derive(PartialEq, Eq, Clone, Debug)]
422+
// pub struct ListNode {
423+
// pub val: i32,
424+
// pub next: Option<Box<ListNode>>
425+
// }
426+
//
427+
// impl ListNode {
428+
// #[inline]
429+
// fn new(val: i32) -> Self {
430+
// ListNode {
431+
// next: None,
432+
// val
433+
// }
434+
// }
435+
// }
436+
impl Solution {
437+
pub fn merge_k_lists(mut lists: Vec<Option<Box<ListNode>>>) -> Option<Box<ListNode>> {
438+
let n = lists.len();
439+
Self::dfs(&mut lists, 0, n)
440+
}
441+
442+
fn dfs(
443+
lists: &mut Vec<Option<Box<ListNode>>>,
444+
start: usize,
445+
end: usize,
446+
) -> Option<Box<ListNode>> {
447+
if end - start <= 1 {
448+
if lists.get(start).is_some() {
449+
return lists[start].take();
450+
}
451+
return None;
452+
}
453+
let mid = start + (end - start) / 2;
454+
let mut left = Self::dfs(lists, start, mid);
455+
let mut right = Self::dfs(lists, mid, end);
456+
let mut dummy = Box::new(ListNode::new(0));
457+
let mut cur = &mut dummy;
458+
while left.is_some() || right.is_some() {
459+
let mut next = None;
460+
if left.is_some()
461+
&& (right.is_none() || left.as_ref().unwrap().val < right.as_ref().unwrap().val)
462+
{
463+
let t = left.as_mut().unwrap().next.take();
464+
next = left.take();
465+
left = t;
466+
} else {
467+
let t = right.as_mut().unwrap().next.take();
468+
next = right.take();
469+
right = t;
470+
}
471+
cur.next = next;
472+
cur = cur.next.as_mut().unwrap();
473+
}
474+
dummy.next
475+
}
476+
}
477+
```
478+
360479
### **...**
361480

362481
```

‎solution/0000-0099/0023.Merge k Sorted Lists/README_EN.md

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -348,6 +348,117 @@ public class Solution {
348348
}
349349
```
350350

351+
### **TypeScript**
352+
353+
```ts
354+
/**
355+
* Definition for singly-linked list.
356+
* class ListNode {
357+
* val: number
358+
* next: ListNode | null
359+
* constructor(val?: number, next?: ListNode | null) {
360+
* this.val = (val===undefined ? 0 : val)
361+
* this.next = (next===undefined ? null : next)
362+
* }
363+
* }
364+
*/
365+
366+
function mergeKLists(lists: Array<ListNode | null>): ListNode | null {
367+
const n = lists.length;
368+
const dfs = (start: number, end: number) => {
369+
if (end - start <= 1) {
370+
return lists[start] ?? null;
371+
}
372+
373+
const mid = (start + end) >> 1;
374+
let left = dfs(start, mid);
375+
let right = dfs(mid, end);
376+
377+
const dummy = new ListNode();
378+
let cur = dummy;
379+
while (left || right) {
380+
let next: ListNode;
381+
if (
382+
(left ?? { val: Infinity }).val <
383+
(right ?? { val: Infinity }).val
384+
) {
385+
next = left;
386+
left = left.next;
387+
} else {
388+
next = right;
389+
right = right.next;
390+
}
391+
cur.next = next;
392+
cur = next;
393+
}
394+
return dummy.next;
395+
};
396+
return dfs(0, n);
397+
}
398+
```
399+
400+
### **Rust**
401+
402+
```rust
403+
// Definition for singly-linked list.
404+
// #[derive(PartialEq, Eq, Clone, Debug)]
405+
// pub struct ListNode {
406+
// pub val: i32,
407+
// pub next: Option<Box<ListNode>>
408+
// }
409+
//
410+
// impl ListNode {
411+
// #[inline]
412+
// fn new(val: i32) -> Self {
413+
// ListNode {
414+
// next: None,
415+
// val
416+
// }
417+
// }
418+
// }
419+
impl Solution {
420+
pub fn merge_k_lists(mut lists: Vec<Option<Box<ListNode>>>) -> Option<Box<ListNode>> {
421+
let n = lists.len();
422+
Self::dfs(&mut lists, 0, n)
423+
}
424+
425+
fn dfs(
426+
lists: &mut Vec<Option<Box<ListNode>>>,
427+
start: usize,
428+
end: usize,
429+
) -> Option<Box<ListNode>> {
430+
if end - start <= 1 {
431+
if lists.get(start).is_some() {
432+
return lists[start].take();
433+
}
434+
return None;
435+
}
436+
let mid = start + (end - start) / 2;
437+
let mut left = Self::dfs(lists, start, mid);
438+
let mut right = Self::dfs(lists, mid, end);
439+
let mut dummy = Box::new(ListNode::new(0));
440+
let mut cur = &mut dummy;
441+
while left.is_some() || right.is_some() {
442+
let mut next = None;
443+
if left.is_some()
444+
&& (right.is_none() || left.as_ref().unwrap().val < right.as_ref().unwrap().val)
445+
{
446+
let t = left.as_mut().unwrap().next.take();
447+
next = left.take();
448+
left = t;
449+
} else {
450+
let t = right.as_mut().unwrap().next.take();
451+
next = right.take();
452+
right = t;
453+
}
454+
cur.next = next;
455+
cur = cur.next.as_mut().unwrap();
456+
}
457+
dummy.next
458+
}
459+
}
460+
```
461+
351462
### **...**
352463

353464
```

‎solution/0000-0099/0023.Merge k Sorted Lists/Solution.rs

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
// Definition for singly-linked list.
2+
// #[derive(PartialEq, Eq, Clone, Debug)]
3+
// pub struct ListNode {
4+
// pub val: i32,
5+
// pub next: Option<Box<ListNode>>
6+
// }
7+
//
8+
// impl ListNode {
9+
// #[inline]
10+
// fn new(val: i32) -> Self {
11+
// ListNode {
12+
// next: None,
13+
// val
14+
// }
15+
// }
16+
// }
17+
impl Solution {
18+
pub fn merge_k_lists(mut lists: Vec<Option<Box<ListNode>>>) -> Option<Box<ListNode>> {
19+
let n = lists.len();
20+
Self::dfs(&mut lists, 0, n)
21+
}
22+
23+
fn dfs(
24+
lists: &mut Vec<Option<Box<ListNode>>>,
25+
start: usize,
26+
end: usize,
27+
) -> Option<Box<ListNode>> {
28+
if end - start <= 1 {
29+
if lists.get(start).is_some() {
30+
return lists[start].take();
31+
}
32+
return None;
33+
}
34+
let mid = start + (end - start) / 2;
35+
let mut left = Self::dfs(lists, start, mid);
36+
let mut right = Self::dfs(lists, mid, end);
37+
let mut dummy = Box::new(ListNode::new(0));
38+
let mut cur = &mut dummy;
39+
while left.is_some() || right.is_some() {
40+
let mut next = None;
41+
if left.is_some()
42+
&& (right.is_none() || left.as_ref().unwrap().val < right.as_ref().unwrap().val)
43+
{
44+
let t = left.as_mut().unwrap().next.take();
45+
next = left.take();
46+
left = t;
47+
} else {
48+
let t = right.as_mut().unwrap().next.take();
49+
next = right.take();
50+
right = t;
51+
}
52+
cur.next = next;
53+
cur = cur.next.as_mut().unwrap();
54+
}
55+
dummy.next
56+
}
57+
}

‎solution/0000-0099/0023.Merge k Sorted Lists/Solution.ts

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* class ListNode {
4+
* val: number
5+
* next: ListNode | null
6+
* constructor(val?: number, next?: ListNode | null) {
7+
* this.val = (val===undefined ? 0 : val)
8+
* this.next = (next===undefined ? null : next)
9+
* }
10+
* }
11+
*/
12+
13+
function mergeKLists(lists: Array<ListNode | null>): ListNode | null {
14+
const n = lists.length;
15+
const dfs = (start: number, end: number) => {
16+
if (end - start <= 1) {
17+
return lists[start] ?? null;
18+
}
19+
20+
const mid = (start + end) >> 1;
21+
let left = dfs(start, mid);
22+
let right = dfs(mid, end);
23+
24+
const dummy = new ListNode();
25+
let cur = dummy;
26+
while (left || right) {
27+
let next: ListNode;
28+
if (
29+
(left ?? { val: Infinity }).val <
30+
(right ?? { val: Infinity }).val
31+
) {
32+
next = left;
33+
left = left.next;
34+
} else {
35+
next = right;
36+
right = right.next;
37+
}
38+
cur.next = next;
39+
cur = next;
40+
}
41+
return dummy.next;
42+
};
43+
return dfs(0, n);
44+
}

0 commit comments

Comments
 (0)