LeetCode 21：合并两个有序链表

LeetCode 21：合并两个有序链表

题目描述

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

【示例】

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
【难度】
简单

解题

【思路】
    两个链表都是有序的，所以要完成的就是在对两个链表遍历的过程中，根据当前节点的大小，对节点进行断开和链接。

迭代

    迭代时最直观的也是最容易被考虑到的方法。我们需要做几件事：

1. 指定一个指向较小元素的指针L1和指向较大元素的指针L2。
2. 找到L1所在链表大于L2时的节点前一个结点的位置，并将当前节点的下一个位置指向原L2。
3. 交换L1下一个节点和L2，交换后的L1元素仍然比L2元素小，因此可以迭代下去。
   以此循环永远是最后一个元素较小的链表先到达尾部，不用考虑其中一个链表遍历到最后一个节点之后的操作。
   以下是代码：

/**
 * 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) {
        if (l1 == nullptr)
            return l2;
        if (l2 == nullptr)
            return l1;
        
        ListNode *head = nullptr;
        //若l1元素值比l2大，则交换
        if (l1->val > l2->val){
            head = l1;
            l1 = l2;
            l2 = head;
        }
        
        head = l1;  //head元素一定是最小值
        
        while (l1 && l2){
            while (l1->next && l1->next->val <= l2->val){
                l1 = l1->next;
            }
            //下面四行的目的是保证l1元素的值永远小于l2元素的值
            ListNode *temp_node = l1->next;
            l1->next = l2;
            l1 = l2;
            l2 = temp_node;
        }
        
        return head;
    }
};

递归

递归和迭代本质思想是一样的，只是把保证某一个指针永远指向当前较小值节点以及若该指针元素值较大时则交换，只是将最开始判断大小以及迭代中的操作放到整个递归过程中。以下是代码：

/**
 * 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) {
        if (l1 == nullptr)
            return l2;
        if (l2 == nullptr)
            return l1;
        
        if (l1->val > l2->val){
            l2->next = mergeTwoLists(l2->next, l1);            
            return l2;
        }
        else{
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        }
    }
};