【力扣专题栏】合并K个升序链表，3种解法讲解如何实现vector容器里面多个链表的合并？

题解目录

1、题目描述+解释
- 2、算法原理解析

1、题目描述+解释

解释：首先vector容器里面放有多个元素，每个元素是一个链表，每个链表含有0个或多个节点。如下简图：

2、算法原理解析

(1)，优先级队列算法1

(2)、优先级队列算法2

(3)递归+归并算法

当到达递归结束条件时，就开始往回归并。

4、代码编写

(1)优先级队列算法1代码编写

cpp 复制代码

class Solution {
struct cmp
{
    bool operator()(const ListNode* L1,const ListNode* L2)
    {
        return L1->val > L2->val;
    }
};
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //创建优先级队列
        priority_queue<ListNode*,vector<ListNode*>,cmp> pq;
        //遍历容器，容器里面的每个元素是链表
        for(auto& L:lists)
        {
            //L是每个元素的头节点
            //从第一个链表开始加入到优先级队列中去
            while(L)
            {
                //L链表不为空才加入
                pq.push(L);
                L=L->next;
            }
            //循环完一次，进入下一个链表
        }
        // //测试打印优先级队列中的数据
        // while(!pq.empty())
        // {
        //     cout<<pq.top()->val<<"->";
        //     pq.pop();
        // }
        // return nullptr;

        //然后创建一个新链表，依次取出top元素，链接到后面
        ListNode* NewHead=new ListNode(0);
        ListNode* ptail=NewHead;
        while(!pq.empty())
        {
            ListNode* TopNode=pq.top();
            pq.pop();
            //链接
            ptail->next=TopNode;
            ptail=TopNode;
        }
        //末尾得加结束标志
        ptail->next=nullptr;
        //再销毁
        ptail=NewHead->next;
        delete NewHead;
        return ptail;
    }
};

(2)优先级队列算法2代码编写

cpp 复制代码

class Solution {
struct cmp    
{
    bool operator()( const ListNode* l1, const ListNode* l2)
    {
        return l1->val>l2->val;
    }
};

public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //创建优先级队列
        priority_queue<ListNode*,vector<ListNode*>,cmp> pq_list;
        //每个链表的头结点入队列
        for(auto& l:lists)
        {
            //取出容器中的元素，为链表
            //判断是否为空
            if(l)
            {
                pq_list.push(l);
            }
        }

        //出堆顶元素
        ListNode* NewHead=new ListNode(0);
        ListNode* ptail=NewHead;
        while(!pq_list.empty())
        {
            ListNode* PcurNode=pq_list.top();
            //删除
            pq_list.pop();
            //链接到新的链表
            ptail->next=PcurNode;
            ptail=PcurNode;
            //把每个链表的后面节点入堆
            if(PcurNode->next)
            {
                pq_list.push(PcurNode->next);
            }
        }
        return NewHead->next;
    }
};

(3)递归+归并算法代码编写

cpp 复制代码

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //递归+归并
        return mergaLists(lists,0,lists.size()-1);
    }

    ListNode* mergaLists(vector<ListNode*>& v_list,int left,int right)
    {
        if(left>right)
        {
            return nullptr;
        }

        if(left==right)
        {
            return v_list[left];
        }

        //求中间值
        int mid=(left+right)>>1;

        //[left,mid],[mid+1,right]
        ListNode* L1=mergaLists(v_list,left,mid);
        ListNode* R1=mergaLists(v_list,mid+1,right);

        //合并
        return merge_final_lis(L1,R1);
    }

    ListNode* merge_final_lis(ListNode* L1,ListNode* R1)
    {
        //创建一个头结点
        ListNode* head=new ListNode(0);
        ListNode* ptail=head;
        if(L1==nullptr)
        {
            return R1;
        }
        if(R1==nullptr)
        {
            return L1;
        }

        ListNode* cur1=L1;
        ListNode* cur2=R1;
        while(cur1&&cur2)
        {
            if(cur1->val <= cur2->val)
            {
                ptail=ptail->next=cur1;//赋值运算符从右到左
                cur1=cur1->next;
            }
            else
            {
                ptail=ptail->next=cur2;
                cur2=cur2->next;
            } 
        }
        if(cur1==nullptr)
        {
            ptail->next=cur2;
        }
        if(cur2==nullptr)
        {
            ptail->next=cur1;
        }

        return head->next;
    }
};