Leetcode 23. 合并 K 个升序链表

JehanRio

已于 2023-09-08 09:52:29 修改

阅读量178

点赞数 1

分类专栏： Leetcode专栏文章标签：链表 leetcode 数据结构

于 2023-05-31 17:43:35 首次发布

本文链接：https://blog.csdn.net/weixin_51322383/article/details/130974094

版权

Leetcode专栏专栏收录该内容

278 篇文章 2 订阅

订阅专栏

文章提供了三种不同的编程解决方案来合并K个升序链表，主要利用了C++中的lambda表达式和优先队列以及Go语言中的二叉堆。所有方法的目标是创建一个新的链表，其中节点按升序排列。第一种方法使用了lambda优先队列，第二种和第三种方法分别在二刷和三刷时采用，包括了自解和归并排序的思路。

摘要由CSDN通过智能技术生成

题目

在这里插入图片描述
Leetcode 23. 合并 K 个升序链表

代码（首刷看解析，lambda优先队列）

 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](ListNode* a, ListNode* b) { return a->val > b->val; };
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> q(cmp);
        for(auto& node : lists) {
            if(node)    // 防止插入空指针
                q.push(node);
        }
        auto head = new ListNode(0);
        auto p = head;
        while(!q.empty()) {
            p->next = q.top();
            p = p->next;
            q.pop();
            if(p->next) 
                q.push(p->next);
        }
        return head->next;
    }
};

代码（8.7 二刷自解）

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](ListNode* a, ListNode* b) { return a->val > b->val;};
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> q(cmp);
        for(auto node : lists) {
            if(node) q.push(node);
        }
        auto dummy = new ListNode(0);
        auto p = dummy;
        while(!q.empty()) {
            auto top = q.top();
            p->next = top;
            q.pop();
            if(top->next)
                q.push(top->next);
            p = p->next;
        }
        return dummy->next;
    }
};

学习GO的小根堆

func mergeKLists(lists []*ListNode) *ListNode {
    if len(lists) == 0 {return nil}
    h := IntHeap{}
    heap.Init(&h)
    for _, list := range lists {
        if list != nil {
            heap.Push(&h, list)
        }
    }
    dummy := &ListNode{}
    p := dummy
    for h.Len() > 0 {
        top := heap.Pop(&h).(*ListNode)
        p.Next = top
        p = p.Next
        if top.Next != nil {
            heap.Push(&h, top.Next)
        }
    }
    return dummy.Next
}
type IntHeap []*ListNode
func (h IntHeap) Less(i, j int) bool { return h[i].Val < h[j].Val}
func (h IntHeap) Swap(i, j int) {h[i], h[j] = h[j], h[i]}
func (h IntHeap) Len() int { return len(h) }
func (h *IntHeap) Push(x interface{}) {*h = append(*h, x.(*ListNode))}  // 这两个函数顶层是interface{}
func (h *IntHeap) Pop() interface{} {
    n := len(*h)
    ans := (*h)[n-1]
    *h = (*h)[:n-1]
    return ans
}

代码（9.8 三刷看解析归并）

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size()-1);
    }
    ListNode* merge(vector<ListNode*>& lists, int l, int r) {
        if(l == r)
            return lists[l];
        if(l > r)
            return nullptr;
        int mid = (l+r)/2;
        return merge2Lists(merge(lists, l, mid), merge(lists, mid+1, r));
    }
    ListNode* merge2Lists(ListNode* a, ListNode* b) {
        if(!a || !b) 
            return a ? a : b;
        ListNode head, *tail = &head;
        auto aptr = a, bptr = b;
        while(aptr && bptr) {
            if(aptr->val < bptr->val) {
                tail->next = aptr;
                aptr = aptr->next;
            } else {
                tail->next = bptr;
                bptr = bptr->next;
            }
            tail = tail->next;
        }
        if(aptr) tail->next = aptr;
        else tail->next = bptr;
        return head.next;
    }
};

自解

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        auto cmp = [](auto& a, auto& b) { return a->val > b->val; };
        priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> q(cmp);
        for(auto& l : lists) {
            if(l)
                q.push(l);
        } 
        ListNode ans, *tail = &ans;
        while(!q.empty()) {
            auto top = q.top();
            q.pop();
            tail->next = top;
            tail = tail->next;
            if(top->next)
                q.push(top->next);
        }
        return ans.next;
    }
};