[C++]LeetCode: 13 Merge Two Sorted Lists

题目：

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

算法复杂度：O(m+n),m和n分别是两条链表的长度，空间复杂度是O(1)

思路：合并两个有序链表，返回新链表。新链表有序，且由L1和L2的节点链接而成。建立虚拟空头结点和一个list。然后使用归并思想，将每次比较较小值存入链表。维护三个指针，对应三个链表。需要不断移动指针，建立节点关系。。

Attention: 合理利用链表的结构体，Node和*List; 虚拟头结点的使用可以使代码更加简洁。

时间：80ms

！！！记着怎么定义这样的结构体。

typedef struct node{  
    int data;  
    struct node *next;  
}node, *List;  

AC Code:

<pre name="code" class="cpp">/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
    //合并两个有序链表，返回新链表。新链表有序，且由L1和L2的节点链接而成。
    //建立虚拟空头结点和一个list。然后使用归并思想，将每次比较较小值存入链表。维护三个指针，对应三个链表。需要不断移动指针，建立节点关系。。
    //Attention: 合理利用链表的结构体，Node和*List; 虚拟头结点的使用可以使代码更加简洁。
    
    if(l1 == NULL)
        return l2;
    if(l2 == NULL)
        return l1;
    
    //此处的初始化也是精华！！需要学习。
    ListNode dummyhead(0);
    ListNode *p = &dummyhead;
    
    while(l1 != NULL && l2 != NULL)
    {
        if(l1->val <= l2->val)
        {
            //仅初始化一次dummyhead的值，dummyhead是ListNode结构体。p最开始指向dummyhead，后面就移动了。
            p->next = l1;
            l1 = l1->next;
        }
        else
        {
            p->next = l2;
            l2 = l2->next;
        }
        p = p->next;
    }
    
    //此处很巧妙，l1或l2哪个链表非空，直接让p->next指向非空链表即可。不需要继续处理。（链表的特点！！只需要定义链接关系）
    if(l1 != NULL)
        p->next = l1;
    else
        p->next = l2;
    
    //此处dummyhead作为一个节点，调用方式和list不同。dummyhead.next
    return dummyhead.next;  
    }
};

解法二：

思路：先判断头结点，然后再进行接下来链表的连接。

Attention：建立dummyhead和result关系的正确位置！！（my_code）

时间：52ms

AC Code:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        //合并两个有序链表，返回新链表。新链表有序，且由L1和L2的节点链接而成。
        //思路：使用归并的思想，每次选择值较小的节点接到新链表的后面。
        //Attention: 注意每次比较只是确定一个节点，如先确定L1第一个节点，第二次比较需要比较l1第二个节点和l2第一个节点。
         
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
            
        ListNode* dummyhead = new ListNode(0);    
        ListNode* result;
        //这句没有起到连接dummyhead和result的作用。(下一句error code代码)
        //dummyhead->next = result;
        if(l1 == NULL && l2 == NULL)
            return result;
        
        //判断第一个节点
        if(l1->val <= l2->val)
        {
            dummyhead->next = l1;
            l1 = l1->next;
        }
        else
        {
            dummyhead->next = l2;
            l2 = l2->next;
        } 
        //Attention:在确定了dummyhead后，这句才建立了两者关系！！关键点！！ （修改后的位置。AC CODE）
        result = dummyhead->next;
        
        //确定新链表
        while(l1 != NULL && l2 != NULL)
        {
            if(l1->val <= l2->val)
            {
                result->next = l1;
                l1 = l1->next;
            }
            else 
            {
                result->next = l2;
                l2 = l2->next;
            }
            result = result->next;
        }
        
        if(l1 != NULL)
            result->next = l1;
        else
            result->next = l2;
        
        result = dummyhead->next;
        delete dummyhead;
        return result;
        
    }
};