优先级队列小练习

/**
 * 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 {
private:
    void exch(vector<ListNode*> &lists, const int a, const int b){
        ListNode *t = lists[a];
        lists[a] = lists[b];
        lists[b] = t;
    }

    void sink(vector<ListNode*> &lists, int pt) {
        while(pt*2 < lists.size()){
            int less = pt*2;
            if(pt*2 + 1 < lists.size() && lists[pt*2 + 1]->val < lists[pt*2]->val){
                less = pt*2 + 1;
            }   
            if(lists[pt]->val < lists[less]->val)
                break;
            exch(lists, pt, less);
            pt = less;
        }
    }

    void swim(vector<ListNode*> &lists, int pt) {
        while(pt > 1 && lists[pt/2]->val > lists[pt]->val){
            exch(lists, pt, pt/2);
            pt /= 2;
        }
    }

    int getHeapPos(int pt){
        return pt+1;
    }

public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode *head = new ListNode;
        if(lists.size() == 0 || (lists.size() == 1 && lists[0] == nullptr)) 
            return nullptr;
        vector<ListNode*> heaplists(1, nullptr);
        for(int i = 0; i < lists.size(); i++){
            if(lists[i] != nullptr){
                heaplists.emplace_back(lists[i]);
                swim(heaplists, heaplists.size() - 1);
            }
        }
        if(heaplists.size() == 1) return nullptr;
        ListNode *p = heaplists[1];
        head->next = p;
        while(1){
            heaplists[1] = heaplists[1]->next;
            if(heaplists[1]) sink(heaplists, 1);
            else{
                exch(heaplists, 1, heaplists.size() - 1);
                heaplists.pop_back();
                sink(heaplists, 1);
            }
            if(heaplists.size() <= 1) break;
            p->next = heaplists[1];
            p = p->next;
        }
        
        return head->next;
    }
};

题目来源：https://leetcode-cn.com/problems/merge-k-sorted-lists/
这个代码是自己写的一个对于小顶堆的实现。写的不算完美，还有很多可以优化的空间。理论上来说如果链表个数很多，这个算法的性能会比分治法好一些。但是题目给的链表个数并不多。