《剑指offer》——合并两个排序的链表

本期给大家带来的是 合并两个排序的链表 这道题的讲解！！！

 接下来，我们还是先从题干的内容入手，先分析一波题目，在进行画图思考操作。

 题目如下：

示例1

输入：{1,3,5},{2,4,6}

返回值：{1,2,3,4,5,6}

示例2

输入：{},{}

返回值：{}

示例3

输入：{-1,2,4},{1,3,4}

返回值：{-1,1,2,3,4,4}

---

解题思想

a）迭代思想

b）递归思想

---

题意分析：

我们读完题意后，发现题干的意思其实很简单。

1. 给出的链表均为有序的链表，因此免除了我们自己对其进行排序的操作；
2. 其次，对于链表中的元素如果有重复项，那么排序后输出的只有一项即可；

接下来，我给出两种不同的思想来进行解决！

---

a）迭代思想

 解题思路：

1. 首先整体的思路即是 ：从首结点开始依次比较两个链表中的结点的值，比较完一次之后把小的结点插入到新的链表上，紧接着往后移动一个位置在进行比较，依次类推。
2. 如果比较过程中遇到相同的结点，随便插入一个即可
3. 最后，当比较过程中如果有一方的链表为空了，则只需将另外一个链表剩余的结点值链接到链表的结尾即可。

图解如下：

•  第一步：

 

•  第二步：

 

•  第三步：

 

•  第四步：

•  第五步：

•  第六步：

 

 

代码如下：

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/

class Solution {
  public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
		//首先，判断一下刚开始时是否有链表为空的情况
        if (pHead1 == NULL) return pHead2;
        if (pHead2 == NULL) return pHead1;
        if (pHead1 == NULL && pHead2 == NULL) 
		{
            return NULL;
        }
		
        //我们在进行初始化操作时，可以设置一个虚拟头结点，也叫哨兵结点
		//这样做的好处是便于,刚开始时每一个插入的结点都有一个前驱结点
		ListNode* head=new ListNode(-1); 
		ListNode *newhead=head;

		 //接下来就开始进行进行比较
		 while(pHead1 && pHead2)
		 {
			 if(pHead1->val <= pHead2->val) //比较得出结点值中较小的一个
			 {
				newhead->next=pHead1; //取出较小的一个节点
                pHead1=pHead1->next;  //取出后往后移动一位
			 }
			 else 
			 {
				newhead->next=pHead2;
                pHead2=pHead2->next;		 
			 }
			 newhead=newhead->next; //链接一位后，就将新链表的指向往后移一位

		 }
        //比较完之后如果其中一个为空了，则将另外一个链表的结点链接在后面
		if(pHead2==NULL) 
            newhead->next=pHead1;
        if(pHead1==NULL)
            newhead->next=pHead2;
        return head->next;
    }
};

 性能分析：

• 时间复杂度：因为需要遍历两个链表，所以时间复杂度为O(n+m)  n m 分别表示pHead1, pHead2的长度
• 空间复杂度 :  因为没开辟新空间。所以空间复杂度为O(1)

---

b）递归思想

 解题思路：

• 对于 【 ListNode* Merge(ListNode* pHead1, ListNode* pHead2) 】这一段代码的函数功能为：合并两个单链表，返回两个单链表头结点值小的那个节点。

• 因此，本题递归的思想即为：两个链表头部值较小的一个节点与剩下元素的 【Merge】操作结果合并。

代码如下：

class Solution {
  public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        //首先，还是先判断一下刚开始时是否有链表为空的情况
        if (pHead1 == NULL) return pHead2;
        if (pHead2 == NULL) return pHead1;
        if (pHead1 == NULL && pHead2 == NULL) {
            return NULL;
        }

         //如果一个链表的首结点比另外一个链表的首结点大，此时递归去查看较小链表中其余结点的值跟此时较大链表的首结点值的大小
        if (pHead1->val <= pHead2->val) 
		{
            pHead1->next = Merge(pHead1->next, pHead2);
            return pHead1;
        } 
		else //同理
		 {
            pHead2->next = Merge(pHead1, pHead2->next);
            return pHead2;
        }
    }
};

 

 性能分析：

• 时间复杂度：因为需要遍历两个链表，所以时间复杂度为O(n+m)  n m 分别表示pHead1, pHead2的长度
• 空间复杂度 : 递归调用 merge 函数时需要消耗栈空间，栈空间的大小取决于递归调用的深度。结束递归调用时 merge  函数最多调用 n+m ，所以空间复杂度为O(n+m)

---

到此关于本题便讲解结束了，当然本题的结题思路并不止这两种，如果大家有兴趣还可以研究研究！！！