leetcode23 合并k个升序链表

记录一下这道题，觉得用堆或者分治思想都很优雅

//使用小根堆，优先队列做法
class Solution {
private:

    struct cmp{
        bool operator () ( ListNode* a, ListNode* b ){
            return a->val > b->val; //这里的比较大小每次都弄反。。。
        }
    };

public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {

        priority_queue< ListNode*, vector<ListNode*>, cmp > pq;

        for( auto it : lists ){
            if( it )
                pq.push( it );
        }

        ListNode* resDummyHead = new ListNode(-1);  ListNode* resEnd = resDummyHead;

        while( !pq.empty() ){

            ListNode* cur = pq.top();
            resEnd->next = cur;
            resEnd = resEnd->next;
            pq.pop();

            if( cur->next )
                pq.push(cur->next);
        }
        return resDummyHead->next;
    }
};

//使用分治思想
class Solution {
public:
    // 合并两个有序链表
    ListNode* merge(ListNode* p1, ListNode* p2){
        if(!p1) return p2;
        if(!p2) return p1;
        if(p1->val <= p2->val){
            p1->next = merge(p1->next, p2);
            return p1;
        }else{
            p2->next = merge(p1, p2->next);
            return p2;
        }
    }

    ListNode* merge(vector<ListNode*>& lists, int start, int end){
        if(start == end) return lists[start];
        int mid = (start + end) / 2;
        ListNode* l1 = merge(lists, start, mid);
        ListNode* l2 = merge(lists, mid+1, end);
        return merge(l1, l2);
    }

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

代码测试用例

#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <queue>

using namespace std;

struct ListNode {
         int val;
         ListNode *next;
         ListNode(int x) : val(x), next(NULL) {}
};

ListNode* createLinkedList(int arr[],int n){

    if( n == 0 )
        return NULL;

    ListNode* head = new ListNode(arr[0]);

    ListNode* curNode = head;
    for(int i = 1; i < n; i++){
        curNode->next = new ListNode(arr[i]);
        curNode = curNode->next;
    }

    return head;
}

void deleteLinkedList(ListNode* head){
    ListNode* curNode = head;
    while( curNode != NULL ){
        ListNode* delNode = curNode;
        curNode = curNode->next;
        delete delNode;
    }
}

void printLinkedList(ListNode* head){

    ListNode* curNode = head;
    while( curNode != NULL ){
        cout << curNode->val << " -> ";
        curNode = curNode->next;
    }

    cout << "NULL" << endl;

}

//这里使用两两逐一合并
class Solution {
public:
    // 合并两个有序链表
    ListNode* merge(ListNode* p1, ListNode* p2){
        if(!p1) return p2;
        if(!p2) return p1;
        if(p1->val <= p2->val){
            p1->next = merge(p1->next, p2);
            return p1;
        }else{
            p2->next = merge(p1, p2->next);
            return p2;
        }
    }

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

int main(){

    int arr[] = {1,4,5}; int arr2[] = {1,3,4}; int arr3[] = {2,6};
    int n = sizeof(arr)/ sizeof(int); int n2 = sizeof(arr2)/ sizeof(int); int n3 = sizeof(arr3)/ sizeof(int);
    ListNode* head = createLinkedList(arr,n); 
    ListNode* head1 = createLinkedList(arr2,n2);
    ListNode* head2 = createLinkedList(arr3,n3);


    vector<ListNode*> lists{ head, head1, head2  };

    ListNode* head3 = Solution().mergeKLists( lists );
    printLinkedList( head3 );

    deleteLinkedList( head3 );

    return 0;
}