23. 合并K个排序链表-H
23. 合并K个排序链表-H
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6
- 分析
这道题合并有序链表，主要是看复杂度，假设k个链表，每个链表n个元素，各方法有：
- 暴力，从头到位合并，复杂度O(nk^2)runtime,O(1)space
- 堆方法,构建k大小的堆，依次读取，插入、退出堆；复杂度O(nk*logk)runtime,O(1)space,见code2
- 通过调整方法1的合并顺序，现在通过两两合并的方式，有公式推导得出，复杂度O(nklogk)runtime,O(1)space
- code3
/**
我的提交执行用时
已经战胜 100.00 % 的 golang 提交记录
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func merge(a,b *ListNode)*ListNode{
head:=&ListNode{0,nil};p:=head
for a!=nil&&b!=nil{
if a.Val>b.Val{
p.Next=b;p=p.Next
b=b.Next
}else{
p.Next=a;p=p.Next
a=a.Next
}
}
if a!=nil{
p.Next=a
}
if b!=nil{
p.Next=b
}
return head.Next
}
func mergeKLists(lists []*ListNode) *ListNode {
i:=0;s:=len(lists)
if s==0{
return nil
}
for s>1{
for j:=0;j<s;j+=2{
if j+1<s{
lists[i]=merge(lists[j],lists[j+1])
}else{
lists[i]=lists[j]
}
i++
}
s=s-s/2;i=0
}
return lists[0]
}
- code2
package main
import (
"container/heap"
"fmt"
)
type ListNode struct {
Val int
Next *ListNode
}
type Item struct {
value *ListNode// 改成自己需要的结构
priority int // The priority of the item in the queue.
index int // The index of the item in the heap.
}
type PriorityQueue []*Item
func (pq PriorityQueue) Len() int { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool {
return pq[i].value.Val< pq[j].value.Val//改成大顶堆,让弹出的顺序是非递减
}
func (pq PriorityQueue) Swap(i, j int) {
pq[i], pq[j] = pq[j], pq[i]
pq[i].index = i
pq[j].index = j
}
func (pq *PriorityQueue) Push(x interface{}) {
n := len(*pq)
item := x.(*Item)
item.index = n
*pq = append(*pq, item)
}
func (pq *PriorityQueue) Pop() interface{} {
old := *pq
n := len(old)
item := old[n-1]
item.index = -1 // for safety
*pq = old[0 : n-1]
return item
}
func mergeKLists(lists []*ListNode) *ListNode {
if len(lists)==0{
return nil
}
//空的不能进入到heap中
pq := make(PriorityQueue, len(lists))
c:=0
for _,b:=range lists{
if b!=nil{
pq[c]=&Item{
b,
0,//这个改成0就行，因为不需要优先级，堆顶元素就是最值
0,
}
c++
}else{
pq=pq[:len(pq)-1]
//有[[nil]]的测试用例，注意控制，不能写入nil,否则堆中swap会交换nil时，崩溃
}
}
heap.Init(&pq)
head:=&ListNode{0,nil};p:=head
for pq.Len() > 0 {
pitem := heap.Pop(&pq)
if pitem==nil{
continue
}
item := pitem.(*Item)
if item.value==nil{
continue
}
p.Next=item.value
p=p.Next
if item.value.Next!=nil{
heap.Push(&pq,&Item{item.value.Next,0,0})
}
}
return head.Next
}
func main() {
lists := []*ListNode{
&ListNode{1, &ListNode{2, &ListNode{5,nil}}},
&ListNode{4, &ListNode{5, &ListNode{6,nil}}},
&ListNode{2, &ListNode{6, nil}},
}
//lists=[]*ListNode{nil}
head:=mergeKLists(lists)
for head!=nil{
fmt.Println(head.Val)
head=head.Next
}
}
- code1
/**
执行用时: 152 ms, 在Merge k Sorted Lists的Go提交中击败了34.81% 的用户
内存消耗: 5.5 MB, 在Merge k Sorted Lists的Go提交中击败了18.42% 的用户
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func merge(a,b *ListNode)*ListNode{
head:=&ListNode{0,nil};p:=head
for a!=nil&&b!=nil{
if a.Val>b.Val{
p.Next=b;p=p.Next
b=b.Next
}else{
p.Next=a;p=p.Next
a=a.Next
}
}
if a!=nil{
p.Next=a
}
if b!=nil{
p.Next=b
}
return head.Next
}
func mergeKLists(lists []*ListNode) *ListNode {
s:=len(lists)
if s==0{
return nil
}
for i:=1;i<s;i++{
lists[0]=merge(lists[0],lists[i])
}
return lists[0]
}