剑指offer：合并两个排序的链表

1. 题目

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

2. 解法一：非递归法

这道题目思路很简单，主要要考虑一些特殊情况。

1. 设置两个指针，分别指向链表1和链表2，判断两个指针数据的大小，将小的那一个指针结点插入到新链表中，直到某个指针到链表末尾。

2. 两个指针并不会同时达到末尾，因此，只要把没有遍历完的那个链表依次加入新链表中即可。

3. 如果输入链表中有空链表，函数只需直接返回另一个链表即可。

4. 我们在构造新链表时，可以构造一个虚拟头结点，这样两个链表的头结点的处理方式就与其他结点相同了，不需要额外处理了。

/*
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;
        ListNode *Head = new ListNode(-1);
        Head->next = NULL;
        ListNode *p = Head;
        ListNode *p1 = pHead1;
        ListNode *p2 = pHead2;
        while(p1!=NULL && p2!=NULL)
        {
            if(p1->val <= p2->val)
            {
                p->next = p1;
                p1 = p1->next;
                p = p->next;
            }
            else{
                p->next = p2;
                p2 = p2->next;
                p = p->next;
            }
        }
        if(p1==NULL)
        {
            p->next = p2;
        }
        if(p2==NULL)
        {
            p->next = p1;
        }
        return Head->next;
    }
};

3. 解法二：递归法

递归解法也比较容易理解，此时不再构造新的链表，直接判断当前两个链表的结点数据大小，哪个小就返回哪个，然后继续判断较小结点的下一个结点和另一个链表的。递归结束的条件就是遍历到两个链表末尾时，此时返回NULL。

class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        // 方法二：递归法
        if(pHead1==NULL)
            return pHead2;
        if(pHead2==NULL)
            return pHead1;
        if(pHead1->val <= pHead2->val)
        {
            pHead1->next = Merge(pHead1->next, pHead2);
            return pHead1;
        }
        else
        {
            pHead2->next = Merge(pHead1, pHead2->next);
            return pHead2;
        }
    }
};