K链表合并 Merge k Sorted Lists

最新推荐文章于 2024-08-10 23:27:32 发布

原创最新推荐文章于 2024-08-10 23:27:32 发布 · 4k 阅读

3 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

234 篇文章

订阅专栏

本文探讨了如何高效地合并K个已排序的链表，首先介绍了几种不同的方法，包括直接合并、分治法（递归与非递归实现）以及使用堆排序的方法。通过对这些方法的时间和空间复杂度进行分析，最终确定了一种既节省空间又高效的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

思想：分布式常见题型。

刚开始的思路：逐一合并，合并的时间复杂度用O(N) ——> TLE

    ListNode *mergeKLists(vector<ListNode *> &lists) {
        if( lists.size() == 0) return nullptr;
        ListNode *p = lists[0];
        for(int i=1; i < lists.size(); i++) {
            p = mergeTwoLists(p, lists[i]);
        }
        return p;
    }

然后，分治法，合并的时间复杂度O(logN)，递归，空间复杂度大 ——> MLE

    ListNode *merge(vector<ListNode*> lists,int left,int right) {
        if(left<right) {
            int mid = (left+right)/2;
            return mergeTwoLists(merge(lists,left,mid), merge(lists,mid+1,right));
        }
        return lists[left];
    }
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        int n = lists.size();
        if(n == 0) return NULL;
        if(n == 1) return lists[0];
        return merge(lists,0,n-1);
    }

最后，分治法，合并的时间复杂度O(logN)，不用递归，空间复杂度O(1) ——> AC

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {  
        int n = lists.size();  
        if (n == 0)  return NULL;
        while (n > 1) {  
            int k = (n + 1) / 2;  
            for (int i = 0; i < n / 2; i++)  
                lists[i] = mergeTwoLists(lists[i], lists[i + k]);  
            n = k;  
        }  
        return lists[0];  
    }  
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        ListNode *dummy = new ListNode(-1);
        ListNode *p = dummy;
        while(l1 != NULL && l2 != NULL) {
            if(l1->val > l2->val) {
                p->next = l2;
                l2 = l2->next;
            }else {
                p->next = l1;
                l1 = l1->next;
            }
            p = p->next;
        }
        if(l1 == NULL) {
            p->next = l2;
        }else if(l2 == NULL) {
            p->next = l1;
        }
        return dummy->next;
    }  
};

方法二：使用堆排序。

这里使用STL的priorit_queue，它是优先队列是队列的一种，不过它可以按照自定义的一种方式（数据的优先级）来对队列中的数据进行动态的排序，

每次的push和pop操作，队列都会动态的调整，以达到我们预期的方式来存储。例如：我们常用的操作就是对数据排序，优先队列默认的是数据大的优

先级高。所以我们无论按照什么顺序push一堆数，最终在队列里总是top出最大的元素，所以这里我们需要改成小顶堆。

该算法维护一个大小为k的堆，每次都会取堆顶的最小元素放到结果中，然后读取该元素的下一个元素（若为空，跳过）放入堆中，重新维护好。因为

每个链表是有序的，每次又是取当前k个元素中最小的，所以当所有链表都读完时结束，这个时候所有元素按从小到大放在结果链表中。这个算法每个

元素要读取一次，即是k*n次，然后每次读取元素要把新元素插入堆中要logk的复杂度，所以总时间复杂度是O(nklogk)。空间复杂度是堆的大小，即为

O(k)。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    //Merge k Sorted Lists : heap sort
    struct cmp {
        bool operator() (ListNode *a,ListNode *b) {
            return a->val > b->val;
        }
    };
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        priority_queue<ListNode*,vector<ListNode*>,cmp> queue;
        for(int i=0;i<lists.size();i++) {
            if(lists[i]!=NULL) {
                queue.push(lists[i]);
            }
        }
        ListNode *head=NULL,*prev=NULL,*temp;
        while(!queue.empty()) {
            temp=queue.top();
            queue.pop();
            if(prev==NULL) {
                head=temp;
            }else {
                prev->next=temp;
            }
            prev=temp;
            if(temp->next!=NULL) {
                queue.push(temp->next);
            }
        }
        return  head;
    }  
};