每天一道LeetCode-----合并两个/多个有序链表为一个新链表

Merge Sorted Array

原题链接Merge Sorted Array

意思是给定两个有序数组，将其合并成一个有序数组，存在nums1中。

如果先只是简单合并成一个新数组，然后将新数组赋值给nums1，基本就算完成了。现在考虑不适用其它内存空间，在nums1上原地合并新数组。
遇到的问题是如果nums1[i] > nums2[j]，那么nums1[i]的位置就应该被赋值给nums2[j]，可是nums1[i]原先的值应该放在哪里呢，接下来还有用这个nums1[i]和nums2[j+1]继续比较呢。如果nums1[i]一直大于nums2[j]，那么所有的nums1[i]又应该放在哪里呢。
方法是在开始合并前就给nums1的前面留出n个大小的空间，而把nums1原来的数据全移动到后面的位置（这里是移动到nums1[n : m+n)），这样，即使nums2全都小于nums1，nums2也可以原封不动的放进nums1中，并且不需要移动nums1原有的数据

0   1   2   3   4   5   下标
1   3   5               nums1
2   4   6               nums2初始时
0   1   2   3   4   5   下标
            1   3   5   nums1
2   4   6               nums2开始合并
0   1   2   3   4   5   下标
1           1   3   5   nums1
2   4   6               nums2
------------------------------
1   2       1   3   5   nums1
2   4   6               nums2
------------------------------
1   2   3   1   3   5   nums1
2   4   6               nums2
------------------------------
1   2   3   4   3   5   nums1
2   4   6               nums2
------------------------------
1   2   3   4   5   5   nums1
2   4   6               nums2
------------------------------
1   2   3   4   5   6   nums1
2   4   6               nums2
------------------------------
合并完成

因为初始时nums1前面已经留有n个大小的空间（nums2的大小），所以在给nums1[0 : m+1)赋值时覆盖的都是合并完成，被放到前面的数据，不会丢失数据
代码如下

class Solution {
public:void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {for(int i = m - 1; i >= 0; --i)nums1[i + n] = nums1[i];int p1 = n;int p2 = 0;int idx = 0;while(p1 < m + n && p2 < n){nums1[idx++] = (nums1[p1] > nums2[p2]) ? nums2[p2++] : nums1[p1++];}while(p1 < m + n)nums1[idx++] = nums1[p1++];while(p2 < n)nums1[idx++] = nums2[p2++];}
};

Merge Two Sorted Lists

原题链接Merge Two Sorted Lists

意思是合并两个有序链表成为一个新的有序链表，比较简单，依次比较即可
细节方法是构造一个头节点，可以解决返回值是null的情况

/*** Definition for singly-linked list.* struct ListNode *     int val;*     ListNode *next;*     ListNode(int x) : val(x), next(NULL) {}* };*/
class Solution {
public:ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {ListNode* header = new ListNode(-1);ListNode* cur = header;while(l1 || l2){int n = 0;if(l1 == NULL || (l1 && l2 && l1->val > l2->val)){n = l2->val;l2 = l2->next;}else if(l2 == NULL || (l1 && l2 && l1->val <= l2->val)){n = l1->val;l1 = l1->next;}cur->next = new ListNode(n);cur = cur->next;}ListNode *ans = header->next;delete header;return ans;}
};

Merge k Sorted Lists

原题链接Merge k Sorted Lists

意思是合并k个有序链表，要求合成的链表也是有序的
两个链表时可以每次比较大小决定取哪个链表的值，k个就不能这么乱来了，不然复杂度会飙升。
可以维护一定大小的最小堆（优先级队列），堆中元素是ListNode类型，每次取最小的，然后插入取出的节点的下一个节点（如果是null就不用插入），直到堆变空为止。
需要注意的是如果ListNode设计时内部重载了operator<函数，那么直接创建优先级队列即可。但是题中给出的ListNode定义没有提供这样的函数，就需要自己实现，此时如果使用优先级队列的话，模板参数要提供三个

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     ListNode *next;*     ListNode(int x) : val(x), next(NULL) {}* };*/class Solution {
public:ListNode* mergeKLists(vector<ListNode*>& lists) {if(lists.size() == 0)return NULL;/** 三个模板参数* ListNode，存储的元素类型* vector<ListNode>，内部存储方式，默认是vector，传入vector就好* cmp，因为没有提供比较大小的函数，需要自己提供，但是不能简单的创建一个函数，需要一个函数对象（行为像函数的类），即重载了operator()的类*/std::priority_queue<ListNode, vector<ListNode>, cmp> pq;for(auto node : lists){if(node != NULL)pq.push(std::move(*node));}ListNode* header = new ListNode(-1);ListNode* cur = header;while(pq.size() > 0){ListNode node = pq.top();pq.pop();cur->next = new ListNode(node.val);cur = cur->next;if(node.next)pq.push(std::move(*node.next));}ListNode* ans = header->next;delete header;return ans;}private:struct cmp{/* * 如果是增序，就判断是否大于* 如果是减序，就判断是否小于* 真怪...*/bool operator()(const ListNode& lhs, const ListNode& rhs){return lhs.val > rhs.val;}  };
};