【数据结构练习题】合并链表

1. 合并两个排序的链表

题目来源：合并两个排序的链表

假设这两个链表为Head1和Head2，因为链表结点之间的关系是通过指针指向建立起来的，所以用链表进行合并不需要另外开辟存储空间，可以直接利用原来两个表的存储空间，合并过程中只需把Head1和Head2两个表中的结点重新进行链接即可。

算法步骤：

1. 创建虚拟头结点ptemp
2. 创建指针p指向虚拟头结点
3. 当指针pHead1和pHead2均未到达表尾时，依次比较pHead1和pHead2所指向的元素值，将较小值的结点插入到指针p所指的结点后面，然后更新指针p指向合并后最新的结点
4. 将非空表的剩余段插入到p所指的结点后面

算法第4步的解释如下：

如下图所示，上面那幅图的pHead1指针已经指向了NULL，代表链表1已经结束，不用再和链表2比较了。只需要修改链表1最后一个结点的指针，就结束这两个有序链表的合并了（图中红线所示）

下图的蓝线为2个链表合并后指针的具体走向。

//链表节点包含的内容
/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

struct ListNode* Merge(struct ListNode* pHead1, struct ListNode* pHead2 ) {
    //说明：pHead1指向第1个链表, pHead2指向第2个链表
    struct ListNode ptemp; //1. 创建虚拟的头结点
    struct ListNode* p = &ptemp; //2. 创建指针p指向虚拟头结点

    //本质：改变两个链表的指针走向
    while (pHead1!=NULL && pHead2!=NULL) //3. 挨个比较大小, 合并到p指向的结点后
    {
        if(pHead1->val > pHead2->val)
        {
            p->next = pHead2;
            pHead2 = pHead2->next;
            p = p->next;
        }
        else 
        {
            p->next = pHead1;
            pHead1 = pHead1->next;
            p = p->next;
        }
    }

    if(pHead1==NULL) p->next = pHead2; //4. 第1个链表结束了，将pHead2接在后面
    if(pHead2==NULL) p->next = pHead1; //5. 第2个链表结束了，将pHead1接在后面

    return ptemp.next;
}

2. 合并k个已排序的链表

题目来源：(合并k个已排序的链表)

合并k个已排序的链表的基础：每次只合并两个有序链表。

将合并后的新链表和下一个待合并的链表进行两个有序链表的合并，不断重复这个过程，直到所有链表合并结束。

算法步骤：

1. 创建指针p1和p2，并初始化为空指针
2. 创建虚拟头结点ptemp
3. 创建指针p3指向虚拟头结点
4. 每次合并前都要设置指针：p1指向合并后链表的第一个结点（刚开始没合并的时候，指向第1个待合并的链表）；p2指向下一个还未合并过的链表；p3指向虚拟头结点。
5. 当合并参数小于链表长度时，合并p1和p2指向的两个有序链表。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

// lists ListNode类一维数组 
// @param listsLen int lists数组长度
struct ListNode* mergeKLists(struct ListNode** lists, int listsLen ) {

    struct ListNode* p1 = NULL; //1. 创建指针p1并初始化
    struct ListNode* p2 = NULL; //1. 创建指针p2并初始化
    struct ListNode ptemp; //2. 创建虚拟的头结点
    struct ListNode* p3 = &ptemp; //3. 创建指针p3指向虚拟头结点
	p3->next = lists[0];

    for (int i=1; i<listsLen; ++i) //4. 两两合并
    {
        p1 = ptemp.next; //p1指向合并后链表的第一个结点
        p2 = lists[i]; //p2指向下一个还未合并过的链表
        p3 = &ptemp; //p3指向虚拟头结点
        
        //本质：改变两个链表的指针走向
        while (p1!=NULL && p2!=NULL)
        {
            if(p1->val > p2->val)
            {
                p3->next = p2;
                p2 = p2->next;
                p3 = p3->next;
            }
            else 
            {
                p3->next = p1;
                p1 = p1->next;
                p3 = p3->next;
            }
        }

        if(p1==NULL) p3->next = p2; //第1个链表结束了，将p2接在后面
        if(p2==NULL) p3->next = p1; //第2个链表结束了，将p1接在后面
    }
    
    return ptemp.next;
}