数据结构-剑指offer-合并有序链表

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

思路：

（1）我的想法是以链表1作为基础链表，将链表2中的元素与链表1比较，比较后将链表2中的节点按照要求插入到链表1中，但这样的思路很麻烦，首先需要改变链表1的结构，此时需要保存链表1中被插入位置的前一个节点的next；其次需要考虑链表1和链表2的长度，如果链表1中被用于比较的节点所指向的下一个节点为nullptr，则将链表2的其他节点直接续到链表1后，如果链表2中用于比较的节点指向的下一个节点为nullptr，则停止比较。但这就需要一个循环。

（2）但插入还是很麻烦，所以还是可以新建一个链表，然后遍历比较并将比较结果按要求添加到新的链表输出。

（2）剑指的想法是：新建一个链表，使用递归的思想对节点进行比较，小的节点添加到新的链表输出。

代码1：

    class Solution {
    public:
       ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
        {
           ListNode* result = NULL;
           ListNode* current = NULL;
            
           if(pHead1 == NULL)
               return pHead2;
           if(pHead2 == NULL)
               return pHead1;
           while(pHead1 != NULL && pHead2 != NULL){
               if(pHead1->val <= pHead2->val){
                    if(result == NULL){
                        current = result = pHead1;
                    } else {
                        current->next = pHead1;
                        current = current->next;
                    }
                    pHead1 = pHead1->next;
               } else {
                    if(result == NULL){
                        current = result = pHead2;
                    } else {
                        current->next = pHead2;
                        current = current->next;
                    }
                    pHead2 = pHead2->next;
               }
           }
           if(pHead1 == NULL){
               current->next = pHead2;
           }
           if(pHead2 == NULL){
               current->next = pHead1;
           }
           return result;
        }
    };

代码2：

    class Solution {
    public:
       ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
        {
           ListNode newHead(0); //建立一个新的头节点
           ListNode *pNewTail = &newHead;//尾指针指向头节点
           //两个链表都不为空时，比较头节点的值大小
           while(pHead1 && pHead2)
           {
               if(pHead1->val <= pHead2->val)
               {
                    pNewTail->next = pHead1;
                    pNewTail = pNewTail->next;
                    pHead1 = pHead1->next;
               }
               else
               {
                    pNewTail->next = pHead2;
                    pNewTail = pNewTail->next;
                    pHead2 = pHead2->next;
               }
           }
           //尾指针指向不为空的节点；如果都为空，则指向空
           pNewTail->next = pHead1 ? pHead1 : pHead2;
           return newHead.next;
        }
    };

代码3：

    class Solution {
    public:
       ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
        {
            if(pHead1 == nullptr)
               return pHead2;
           if(pHead2 == nullptr)
               return pHead1;
           ListNode* pMergedHead = nullptr;
           if(pHead1->val < pHead2->val){
               pMergedHead = pHead1;
               pMergedHead->next = Merge(pHead1->next,pHead2);
           }
           else{
               pMergedHead = pHead2;
               pMergedHead->next = Merge(pHead1,pHead2->next);
           }
           return pMergedHead;
        }
    };