Leetcode第21题：合并两个有序链表

生命无罪，健康万岁，我是laity。

我曾七次鄙视自己的灵魂：

第一次，当它本可进取时，却故作谦卑；

第二次，当它在空虚时，用爱欲来填充；

第三次，在困难和容易之间，它选择了容易；

第四次，它犯了错，却借由别人也会犯错来宽慰自己；

第五次，它自由软弱，却把它认为是生命的坚韧；

第六次，当它鄙夷一张丑恶的嘴脸时，却不知那正是自己面具中的一副；

第七次，它侧身于生活的污泥中，虽不甘心，却又畏首畏尾。

Leetcode第21题：合并两个有序链表

题目

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

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

将两个数组中的数据进行排序，组合成一个新的数组

解题

迭代法

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode per = new ListNode();
        ListNode res = per;
        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                res.next = list1;
                list1 = list1.next;
            } else {
                res.next = list2;
                list2 = list2.next;
            }
            res = res.next;
        }
        if (list1 == null) {
            res.next = list2;
        }
        res.next = list1 == null ? list2 : list1;
        return per.next;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

递归法

    public ListNode mergeTwoLists2(ListNode list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }
        if (list1.val <= list2.val) {
            list1.next = mergeTwoLists2(list1.next, list2);
            return list1;
        } else {
            list2.next = mergeTwoLists2(list1, list2.next);
            return list2;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12

全代码

/**
 * @author: Laity
 * @Project: JavaLaity
 * @Package: LeetCode.t21.MergeTwoLists
 * @Date: 2022年11月13日 18:10
 * @Description: Leetcode第21题：合并两个有序链表
 */
public class MergeTwoLists {
    /**
     * 迭代法
     */
    public ListNode mergeTwoLists1(ListNode list1, ListNode list2) {
        ListNode res = new ListNode();
        ListNode cur = res;  // 当做指针 指向当前的res
        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                cur.next = list1;
                // 抛开相等 指向数值小的下一个 可与 当前的 list2.val继续比较
                list1 = list1.next;
            } else {
                // list1.val > list2.val
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        // 各个ListNode判空：1、预防两个ListNode长度不等；2、解决当传入的ListNode为空时的解决方案
        cur.next = list1 == null ? list2 : list1;
//        if (list1 == null) {
//            cur.next = list2;
//        }
//        if (list2 == null) {
//            cur.next = list1;
//        }
        return res.next;
    }

    /**
     * 递归法
     */
    public ListNode mergeTwoLists2(ListNode list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }
        if (list1.val <= list2.val) {
            list1.next = mergeTwoLists2(list1.next, list2);
            return list1;
        } else {
            list2.next = mergeTwoLists2(list1, list2.next);
            return list2;
        }
    }

    public static void main(String[] args) {
        // 迭代法 Iteration
        // 递归法
    }

    public class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

实力是自信的基础，自信是实力的前提。我是Laity，正在前行的Laity。