【编程题】LeetCode.0023 合并K个升序链表

题目描述：
给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：

输入：lists = []
输出：[]
示例 3：

输入：lists = [[]]
输出：[]

解析：
这题如果只是把所有元素压入一个数组里面再排序是能解，但问题是这样会极大浪费遍历时间，更甚者需要多开一部分空间去存储这个数组，因此，这道题的难点与思考点也不是实现排序的结果，而是如何高效且减少空间使用。

-》总结：链表题的最优解永远不是另开一个空间再存储，而是在链表原有结构上进行改造。

方法一：使用分治
对于K链表的排序，我们可以进行对分，直至把K链表排序变为对K/2对的两链表合并。设平均链表长度为n，总长度为N，分析此方法：
1）、时间复杂度：

1.	分治每次对分，细分至最后为链表长度为1的节点，最大深度为log2K；

2.	对于每层的节点，用于合并子树链表所需的时间是两子树的链表长度总和，
	因此，实际上每层所需时间为总节点数，即Kn=N；
	
3.	总时间复杂度O（n）=Kn*log2K，关于空间复杂度：递归会使用到 O（logk）空间代价的栈空间

代码：

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* mergeTwoLists(ListNode* a,ListNode* b)
    {
        //其中一方为空则返回另一方
	    if(!a||!b)
	    {
            return a ? a : b;
	    }
        //这里不new的原因是避免无法delete造成的无法释放对象
        ListNode head;
        ListNode* head_ptr = &head, * a_ptr=a, * b_ptr=b;
        //只有其中一方为空，即排空一方时，循环才结束
        while (a_ptr&&b_ptr)
        {
	        if(a_ptr->val<b_ptr->val)
	        {
                head_ptr->next = a_ptr;
                a_ptr = a_ptr->next;
	        }
	        else
	        {
                head_ptr->next = b_ptr;
                b_ptr = b_ptr->next;
	        }
            head_ptr = head_ptr->next;
        }
        //循环结束接上还没有空的一边
        head_ptr->next = a_ptr ? a_ptr : b_ptr;
        return head.next;
    }
    //分治与合并
    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) 
	{
        return merge(lists, 0, lists.size() - 1);
    }
};

方法二：优先队列
这题实际上跟本人博客上一道叫产品经理的编程题有点像，都是需要将几个有序的容器进行选取操作。鉴于实际上每个链表已经有序，所以在选取其中一个时，实际上等同于在这些链表的首元素组成的集合中选取最符合的一个元素。其中：

1.	若是使用遍历选取元素，则在确定一个元素所需要的时间为K-1,；

2.	而共有Kn个元素，因此总复杂度为kn*(n-1)=k^2*n;

显然这里第一步可以继续优化。
若我们建立一个优先队列存储这些头结点，由于链表的数量为K，因此当插入及删除某个元素时所需时间可缩短至log2K，接下来的步骤跟2相同。总时间复杂度变为：Kn*log2K，而空间复杂度为开出来的优先队列大小，为K

代码：

class Solution 
{
public:
    struct Status
    {
        int val;
        ListNode* ptr;
        //重载 < 完成队列逻辑，后面的const是一种表明
        bool operator < (const Status &rhs) const
        {
            //优先队列用的是堆排序，因此逻辑取反
            return val > rhs.val;
        }
    };

    priority_queue<Status> my_queue;

    ListNode* mergeKLists(vector<ListNode*>& lists) 
	{
        //先压一轮所有链表的首节点
        for(auto node:lists)
        {
	        if(node)
	        {
                my_queue.push({node->val,node});
	        }
        }

        ListNode head;
        ListNode* my_ptr = &head;

        //当所有链表还没有排空时，循环继续
        while (!my_queue.empty())
        {
	        //获取队列头并弹出，此时队里头就是当前最小值
            auto temp = my_queue.top();
            my_queue.pop();

            my_ptr->next = temp.ptr;
            my_ptr = my_ptr->next;

            //对应的链表若不为空则其的指针指向下一位
            if(temp.ptr->next)
            {
                my_queue.push({ temp.ptr->next->val,temp.ptr->next });
            }
        }
        return head.next;
    }
};