leetcode-23. 合并K个升序链表

 

 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {

        int len = lists.size();
        if(len==0)
            return NULL;

        ListNode* L = new ListNode();
        ListNode* H = L;

        vector<int> res;
        // 将链表中的所有元素存到vector中再用sort排序
        for(int i = 0; i < len; i++){
            while(lists[i]!=NULL){
                res.push_back(lists[i]->val);
                lists[i] = lists[i]->next;
            }
        }
        sort(res.begin(), res.end());
        for(int i = 0; i < res.size(); i++){
            ListNode* tmp = new ListNode(res[i]);
            L-> next = tmp;
            L = L->next;
        }
        return H->next;
    }
};

 使用优先队列

// /**
//  * Definition for singly-linked list.
//  * struct ListNode {
//  *     int val;
//  *     ListNode *next;
//  *     ListNode() : val(0), next(nullptr) {}
//  *     ListNode(int x) : val(x), next(nullptr) {}
//  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
//  * };
//  */
// class Solution {
// public:
//     ListNode* mergeKLists(vector<ListNode*>& lists) {

//         int len = lists.size();
//         if(len==0)
//             return NULL;

//         ListNode* L = new ListNode();
//         ListNode* H = L;

//         vector<int> res;
//         // 将链表中的所有元素存到vector中再用sort排序
//         for(int i = 0; i < len; i++){
//             while(lists[i]!=NULL){
//                 res.push_back(lists[i]->val);
//                 lists[i] = lists[i]->next;
//             }
//         }
//         sort(res.begin(), res.end());
//         for(int i = 0; i < res.size(); i++){
//             ListNode* tmp = new ListNode(res[i]);
//             L-> next = tmp;
//             L = L->next;
//         }
//         return H->next;
//     }
// };

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    
    // 这个就是必须这样写的
    struct cmp{
         bool operator() ( ListNode* a, ListNode* b ){//默认是less函数
             //返回true时，a的优先级低于b的优先级（a排在b的后面）    
             return a->val > b->val;
             // 为什么比较大的在前而最终形成的是小根堆的。
             // 因为这个大的在前的意思是：当大的在前时需要调整，最终形成的时小根堆。
            }
    };
    ListNode* mergeKLists(vector<ListNode*>& lists) {

        int len = lists.size();
        if(len==0)
            return NULL;
        // 使用优先队列
        priority_queue <ListNode*, vector<ListNode*>,cmp> q;
        ListNode* L = new ListNode();
        ListNode* H = L;

        vector<int> res;
        // 将链表中的所有元素存到vector中再用sort排序
        for(int i = 0; i < len; i++){
            if(lists[i])
                q.push(lists[i]);
        }
        while(!q.empty()){
            ListNode* tmp = q.top();
            L->next = tmp;
            q.pop();
            L = L->next;
            // 将最小的使用以后，将其所在链表的下一个元素加入优先队列
            if(tmp->next)
                q.push(tmp->next);
            
        }
        return H->next;
    }
};