Merge k Sorted Lists

最新推荐文章于 2021-12-08 15:59:42 发布

原创最新推荐文章于 2021-12-08 15:59:42 发布 · 512 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种高效算法来合并多个已排序的链表。该算法提供了两种实现方式：非递归归并和递归归并。通过这两种方法可以有效地将多个排序链表合并成一个单一的排序链表。

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

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity

1.非递归归并

/**
 * 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 len = lists.size();
         if(len <=0 )return NULL;
         int step = 1;
         ListNode *head=lists[0];
         while(step < len){
             int first = 0;
             int second = first+step;
             while(first < len){
                 ListNode *h1 = lists[first];
                 ListNode *h2 = lists[second];
                 head=merge(h1,h2);
                 lists[first] = head;
                 if(first!=second)
                    lists[second] = NULL;      
                 first = second + step;
                 second = first +step;
                 second = second >= len ? len-1:second;
             }
             step *= 2;
         }
         return head;
    }
private:
   ListNode *merge(ListNode *h1,ListNode *h2){
       if(h1==h2) return h1;
       if(h1==NULL) return h2;
       if(h2==NULL) return h1;
       ListNode *pre1=NULL,*head = h1;
       while(h1 && h2){
           if(h1->val < h2->val) {
               pre1 = h1;
               h1=h1->next;
           }else if(h1->val ==h2->val){
               ListNode *p = h2->next;
               h2->next = h1->next ;
               h1->next = h2;
               pre1=h1;
               h1 = h2;
               h2=p;
           }else{
               ListNode *p = h2->next;
               if(pre1==NULL){
                   h2->next = h1;
                   head = h2;
                   pre1 = h2;
                   
               }else{
                   h2->next = pre1->next;
                   pre1->next = h2;
                   pre1=h2;
               }
               h2=p;
           }
       }
       if(h2){
           pre1->next = h2;
       }
       return head;
   }
};

2.递归：

class Solution {
public:
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        return mergeKLists(lists,0,lists.size());
    }
private:
    ListNode *mergeKLists(vector<ListNode *> &lists,int low,int high) {
        if(low >= high || lists.size()==0) return NULL;
        if(high-low==1) return lists[low];
        int middle = (low+high)/2;
        ListNode *h1=mergeKLists(lists,low,middle);
        lists[low]=h1;
        ListNode *h2=mergeKLists(lists,middle,high);
        lists[middle]=h2;
        ListNode *head = merge(h1,h2);
        lists[low]=head;
        return head;
    }
    ListNode *merge(ListNode *h1,ListNode *h2){
       if(h1==h2) return h1;
       if(h1==NULL) return h2;
       if(h2==NULL) return h1;
       ListNode *pre1=NULL,*head = h1;
       while(h1 && h2){
           if(h1->val < h2->val) {
               pre1 = h1;
               h1=h1->next;
           }else if(h1->val ==h2->val){
               ListNode *p = h2->next;
               h2->next = h1->next ;
               h1->next = h2;
               pre1=h1;
               h1 = h2;
               h2=p;
           }else{
               ListNode *p = h2->next;
               if(pre1==NULL){
                   h2->next = h1;
                   head = h2;
                   pre1 = h2;
                   
               }else{
                   h2->next = pre1->next;
                   pre1->next = h2;
                   pre1=h2;
               }
               h2=p;
           }
       }
       if(h2){
           pre1->next = h2;
       }
       return head;
   }
};