关于合并有序单链表

1.已知有两个有序的单链表，其头指针分别为head1和head2（注：这里应是没有头结点的单链表 ）实现将这两个链表合并的函数：

          Node* ListMerge(Node *head1,Node *head2)

       这个算法很像我们排序算法中的归并排序，只能说“很像”，因为思想是一样的，但是这个与归并排序还是有区别的，区别如下：

       1.归并排序是针对有序数组，而这里是有序链表；

       2.归并排序排序的时间复杂度为o(nlogn)，而这里的时间复杂度最坏情况下为O(m+n)，最好的情况下为O(min{m,n})。

       3.归并排序需要重新申请空间，而这里无需再重新申请空间，只需改变链表结点的指针指向。

       而这里算法的思想跟归并排序是一样的，都是对两个待归并的线性表分别设置1个指针，比较这两个当前指针的大小，将小的结点加入到合并后的线性表中，并向后移动当前指针。若两个线性表中，至少有一个表扫描完，走将对应的另一个表之间整体添加到合并后的线性表中。在这里： 链表和数组的区别在于，链表只需要改变当前合并序列尾指针的位置，而数组则要将剩下的值依次复制到归并表的尾部 。

非递归方法实现如下：

Node *ListMerge(Node *head1, Node *head2)
{
	if (!head1) return head2;
	if (!head2) return head1;
	Node *head = head1;//合并后的头指针
	Node *p1 = head1;//p1用于扫描链表1
	Node *p2 = head2;//p2用于扫描链表2
	Node *p = head;//p永远指向最新合并的结点
	while (p1 && p2)//如果循环停止，则p1或p2至少有一个为NULL
	{

		///应该考虑是否相交
		if (p1 == p2)
			p->next = p1;

		if (p1->value<p2->value)
		{
			p->next = p1;
			p1 = p1->next;
		}
		else
		{
			p->next = p2;
			p2 = p2->next;
		}
		p = p->next;
	}
	if (p1)//如果链1还没走完
	{
		p->next = p1;
	}
	else if (p2)//如果链2还没走完
	{
		p->next = p2;
	}
	return head;
}

递归方法实现如下：

Node *ListMerge1(Node *head1,Node *head2)//采用递归的方法实现
{
	if(head1==NULL)
		return head2;
	if(head2==NULL)
		return head1;
	Node *head=NULL;
	if(head1->value < head2->value)
	{
		head=head1;
		head->next=ListMerge1(head1->next,head2);
	}
	else
	{
		head=head2;
		head->next=ListMerge1(head1,head2->next);
	}
	return head;
}

2.合并k个长度为M的有序单链表

思路分析：

（1）上面是合并两个有序链表，这里变成合并k个有序链表了，但是不管合并几个，基本还是要两两合并。那么我们首先考虑的方法是能不能利用之前那道题的解法来解答此题。答案是肯定的，但是需要修改，怎么修改呢，最先想到的就是两两合并，就是前两个先合并，合并好了再跟第三个，然后第四个直到第k个。这样的思路是对的，但是效率不高     

（2）换一种思路，这里就需要用到分治法 Divide and Conquer Approach。简单来说就是不停的对半划分，比如k个链表先划分为合并两个k/2个链表的任务，再不停的往下划分，直到划分成只有一个或两个链表的任务，开始合并。举个例子来说比如合并6个链表，那么按照分治法，我们首先分别合并1和4,2和5,3和6。这样下一次只需合并3个链表，我们再合并1和3，最后和2合并就可以了。

ListNode *mergeKLists(vector<ListNode *> &lists) {
        if (lists.size() == 0) return NULL;
        int n = lists.size();
        while (n > 1) {
            int k = (n + 1) / 2;
            for (int i = 0; i < n / 2; ++i) {
                lists[i] = mergeTwoLists(lists[i], lists[i + k]);
            }
            n = k;
        }
        return lists[0];
    }

（3）建立小（大）根堆，我们首先把k个链表的首元素都加入最小堆中，它们会自动排好序。此步骤时间复杂度为O(k)，然后我们每次取出最小的那个元素加入我们最终结果的链表中，然后把取出元素（最小值处）的下一个元素再加入堆中，如果链表中已经有一个为空，则改变heap的大小。此步骤时间复杂度为O(lgk).  不断重复上个步骤直到所有链表都为空。此时k个链表也合并为了一个链表，返回首节点即可。 建堆之间一次，复杂度为O（k）；调整堆（km-1）次，复杂度为（km-1）*o(lgk),即（mn*lgn）。

struct cmp {
    bool operator () (ListNode *a, ListNode *b) {
        return a->val > b->val;
    }
};
 
class Solution {  
public:  
    ListNode *mergeKLists(vector<ListNode *> &lists) {  
        priority_queue<ListNode*, vector<ListNode*>, cmp> q;
        for (int i = 0; i < lists.size(); ++i) {
            if (lists[i]) q.push(lists[i]);
        }
        ListNode *head = NULL, *pre = NULL, *tmp = NULL;
        while (!q.empty()) {
            tmp = q.top();
            q.pop();
            if (!pre) head = tmp;
            else pre->next = tmp;
            pre = tmp;
            if (tmp->next) q.push(tmp->next);
        }
        return head;
    }  
};