Leetcode学习笔记（23. 合并K个排序链表）

关键词：分治法，递归思想

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergetwo(ListNode* l1, ListNode *l2){
        ListNode *out = new ListNode(0), *L;
        L=out;
        while(l1!=nullptr&&l2!=nullptr){
            if(l1->val<l2->val){
                L->next=l1;
                L=l1;
                l1=l1->next;
            }else{
                L->next =l2;
                L=l2;
                l2=l2->next;
            }
        }
        L->next = (l1?l1:l2);
        return out->next;
    }

    ListNode* merge(vector<ListNode*>& lists, int l, int n)
    {
        if(l==n) return lists[l];
        if(l>n) return nullptr;
        int mid = (l+n)>>1;
        return mergetwo(merge(lists, l, mid), merge(lists, mid+1, n));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size()-1);
    }
};

关键词：两两循环排序

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergetwo(ListNode* l1, ListNode *l2){
        ListNode *out = new ListNode(0), *L;
        L=out;
        while(l1!=nullptr&&l2!=nullptr){
            if(l1->val<l2->val){
                L->next=l1;
                L=l1;
                l1=l1->next;
            }else{
                L->next =l2;
                L=l2;
                l2=l2->next;
            }
        }
        L->next = (l1?l1:l2);
        return out->next;
    }

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