LeetCode - 合并两个有序链表

一. 题目描述

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

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

二. 我的解法

比较传统的一道题，感觉跟归并排序很像。

2.1 代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        int count = 0;
        ListNode l3Begin = null;
        ListNode l3 = null;
        while(l1 != null && l2 != null)
        {
            int val = -1;
            
            if(l1.val <= l2.val)
            {
                val = l1.val;
                l1 = l1.next;
            }
            else
            {
                val = l2.val;
                l2 = l2.next;
            }
        
            
            if(count == 0)
            {
                l3Begin = new ListNode(val);
                l3 = l3Begin;
                count = 1;
            }
            else
            {
                l3.next = new ListNode(val);
                l3 = l3.next;
            }
        }
        
        while(l1 != null)
        {
            if(count == 0)
            {
                l3Begin = new ListNode(l1.val);
                l3 = l3Begin;
                count = 1;
            }
            else
            {
                l3.next = new ListNode(l1.val);
                l3 = l3.next;
            }
            l1 = l1.next;
        }
        
        while(l2 != null)
        {
            if(count == 0)
            {
                l3Begin = new ListNode(l2.val);
                l3 = l3Begin;
                count = 1;
            }
            else
            {
                l3.next = new ListNode(l2.val);
                l3 = l3.next;
            }
            l2 = l2.next;
        }
        return l3Begin;
    }
}

2.2 分析

1. 直接采取了类似于归并排序的方式进行合并了，但是由于合并的不是数组，而是链表， 所以增加了一些其他的验证操作。

2. 感觉写的代码并不是很简洁， 应该还有很大的优化空间。

3. 由于采用的方式跟归并排序是一样的，所以就不详细讲解了，感兴趣的同学可以直接搜索归并排序。

三. 更优解法

每次把自己的代码提交上去之后， 都会看一下自己排名在哪里，然后再看看那些运行速度排在我前面的人写的代码，我觉得可以翻阅别人的优秀代码是真的很好，既能找到自己的定位，又能学习别人的代码。

然后， 我翻到了这个兄弟的代码，怎么可以这么整洁，发现宝藏的喜悦以及巨大差距感的打击。

3.1 代码

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if ( l1==null||l2==null){
            if (l1==null&&l2==null)return null;
            else {
                return l1==null?l2:l1;
            }
        }
        ListNode result;
        if (l1.val<l2.val){
            result=l1;
            result.next=mergeTwoLists(l1.next,l2);
        }else {
            result=l2;
            result.next=mergeTwoLists(l1,l2.next);
        }
        return result;
    }
}

3.2 分析

1. 这个代码是用的递归的方式去求解的，既然是递归的方式，其实就没什么好细讲了。

2. 既然是做的简单算法题，就简单说一下如何去快速理解一个递归的代码吧，首先，将被递归调用的函数看成一个黑盒，知道这个黑盒的输入的格式，以及输出格式，然后就可以开始使用这个黑盒了。

3. 在这里，我们知道这个叫做mergeTwoLists的黑盒的输入是两个有序链表，输出是合并后的链表。

4. 那么， 我们在最外层的调用中，是要返回整个排序好的结果的，那么按照递归的思想，最外层其实只需要处理最初的元素即可，然后将剩余的元素交给下一层的递归。

5. 感觉递归并不是一个很难理解的概念，就是使用起来不是很容易，但是一旦成功使用，代码既简洁，可读性还高。

四. 参考

https://leetcode-cn.com/problems/merge-two-sorted-lists/description/