Leecode 23. 合并K个升序链表 链表 递归优先队列

原题链接：Leecode 23. 合并K个升序链表

解法一：找到每一个链表表头最小值的链表，再递归遍历

class Solution {
public:
    ListNode* root=nullptr;
    ListNode* temp=nullptr;
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0)
            return nullptr;
        int tmp=10010,pos=0,num=0;
        for(int i=0;i<lists.size();i++)
        {
            if(lists[i]!=nullptr && lists[i]->val<=tmp)
            {
                tmp=lists[i]->val;
                pos=i;
            }
            if(lists[i]==nullptr)
                num++;
        }
        if(root==nullptr)
        {
            root=lists[pos];
            temp=root;
        }
        else  if(temp!=nullptr)
        {
            temp->next=lists[pos];
            temp=temp->next;   
        }
        if(lists[pos]!=nullptr)
           lists[pos]=lists[pos]->next;
        if(num!=lists.size())
            mergeKLists(lists);
        return root;
    }
};

解法二：顺序依次合并两个链表

class Solution {
public:
    //合并两个链表
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(!list1)
           return list2;
        if(!list2)
           return list1;
        if(list1->val<=list2->val)
        {
            list1->next=mergeTwoLists(list1->next,list2);
            return list1;
        }
        else 
        {
            list2->next=mergeTwoLists(list1,list2->next);
            return list2;
        }
    }

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

解法三：分治依次合并两个链表

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(!list1)
           return list2;
        if(!list2)
           return list1;
        if(list1->val<=list2->val)
        {
            list1->next=mergeTwoLists(list1->next,list2);
            return list1;
        }
        else 
        {
            list2->next=mergeTwoLists(list1,list2->next);
            return list2;
        }
    }
    ListNode* merge(vector<ListNode*>& lists, int l,int r) {
        if(l==r)  return lists[l];
        if(l>r)   return nullptr;
        int mid=(l+r)>>1;
        return mergeTwoLists(merge(lists,l,mid),merge(lists,mid+1,r));
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0)
            return nullptr;
        return merge(lists,0,lists.size()-1);
    }
};

解法四：优先队列

class Solution {
public:
    struct cmp
    {
        bool operator () (const ListNode* a,const ListNode* b) {
            return a->val>b->val;//小顶堆
        }
    };
    //使用优先队列
    priority_queue<ListNode*,vector<ListNode*>,cmp> q;

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size()==0)
            return nullptr;
        for (auto node: lists) {
            if (node) q.push(node);
        }
        ListNode* root=new ListNode();
        ListNode* tmp=root;
        while(!q.empty())
        {
            tmp->next=q.top();
            tmp=tmp->next;
            q.pop();
            if(tmp->next) q.push(tmp->next);
        }
        return root->next;
    }
};