Merge k Sorted Lists

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

思路：合并k个有序链表为一个有序链表。我们可以用先合并两个链表的方法，然后逐个遍历链表数组，与上一个合并结束的链表进行合并，这样最后就可以得到一个有序链表了。这样做的时间复杂度在O(n*k),有点高了。

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

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

 * };

 */

class Solution {

public:

    ListNode *mergeList(ListNode *pHead1,ListNode *pHead2)

    {

        if(pHead1==NULL)

            return pHead2;

        else if(pHead2==NULL)

            return pHead1;

        ListNode *pMergeHead=NULL;

        if(pHead1->val<pHead2->val)

        {

            pMergeHead=pHead1;

            pMergeHead->next=mergeList(pHead1->next,pHead2);

        }

        else

        {

            pMergeHead=pHead2;

            pMergeHead->next=mergeList(pHead1,pHead2->next);

        }

        return pMergeHead;

    }

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

        int n=lists.size();

        if(n<=0)

            return NULL;

        ListNode *head=lists[0];

        for(int i=1;i<n;i++)

        {

            head=mergeList(head,lists[i]);

        }

        return head;

    }

};

思路二：借用网上大神的做法，时间复杂度在O(nlogk).使用堆的做法，是用C++的STL的优先队列，解决此问题。没想到STL的优先队列竟然可以如此用，太强大了，学习了。

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

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

 * };

 */

 struct cmp

 {

     bool operator()(ListNode *pNode1,ListNode *pNode2)

     {

         return pNode1->val > pNode2->val;

     }

 };

class Solution {

public:

    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;

        ListNode *pPre=NULL;

        ListNode *pList;

        while(!queue.empty())

        {

            pList=queue.top();

            queue.pop();

            if(pPre==NULL)

                head=pList;

            else

                pPre->next=pList;

            pPre=pList;

            if(pList->next!=NULL)

                queue.push(pList->next);

        }

        return head;

    }

};