leetcode: 合并两个有序的链表

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

示例：

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

解法1

思路：
我们主要是通过定义两个节点，通过不断比较两个链表的节点值，然后让合并节点依次走过这些比较的节点值，从而达到有序；接下来图解说明比较好理解

1.我们设置两个节点，一个pre只要是头节点的前节点，用来保存头节点的位置，方便返回

2.进行遍历2个链表，此时链表A节点值为1 < B链表值为2，则合并节点成为节点值为1，如图

3.继续比较链表，此时链表B的节点值为2 < A链表的节点值3，则合并节点成为节点值为2，如图

4.继续比较，此时链表A的接地安置为3 < B链表的节点值为4，则合并节点为接地安置为3，如图

5.继续比较，此时链表B的接地安置为4 < A链表的节点值为5，则合并节点为接地安置为4，如图

6.继续比较，此时链表A的接地安置为5 < B链表的节点值为6，则合并节点为接地安置为5，如图

7.继续比较，此时链表B的接地安置为6 < B链表的节点值为7，则合并节点为接地安置为6，如图

8.继续比较，此时链表A的接地安置为7 < B链表的节点值为8，则合并节点为接地安置为7，如图

9.继续比较，此时A链表已经走完，而B链表还未走完，则合并节点为B链表的剩余节点处，即为8成为合并节点,此时pre所指向的路径就是合并的路径，返回pre节点

时间复杂度分析： 这里遍历两个链表，所以时间复杂度整体为O(n),两个链表的比较，也是O(n)，所以整体时间复杂度为O(n)
空间复杂度：这里用了两个节点，但整体空间复杂度为O(1)

代码：

/**
 * 描述： 合并两个有序的链表
 *
 * @author pengjie_yao
 * @date 2019/8/2 14:59
 */
public class MergeTwoLists {

    /**
     * 节点
     */
    public static class ListNode {

        int val;
        ListNode next;

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

    /**
     *  合并两个有序链表
     *
     * @param l1
     * @param l2
     * @return
     */
    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {

        // 1.判空处理
        if (l1 == null && l2 != null) {
            return l2;
        } else if (l1 != null && l2 == null) {
            return l1;
        } else if (l1 == null && l2 == null) {
            return null;
        }
        // 2.设置一个头指针的前节点，用来保存头节点的位置，方便返回结果
        ListNode preHead = new ListNode(-1);
        // 合并的链表指针，用来表示合并的节点处
        ListNode mergeList = preHead;
        while (l1 != null && l2 != null) {
            // 3.如果链表1的节点小于链表2，则将合并的节点指向链表1的节点，并让合并节点成为该节点
            if (l1.val < l2.val) {
                mergeList.next = l1;
                mergeList = l1;
                l1 = l1.next;
            } else {
                // 4.如果链表1的节点大于链表2的节点，则将合并的节点指向链表2的节点，并让合并节点成为该节点
                mergeList.next = l2;
                mergeList = l2;
                l2 = l2.next;
            }
        }
        // 5.如果链表1为空，链表2不为空，则直接将合并节点指向链表2的节点
        if (l1 == null && l2!=null) {
            mergeList.next = l2;
        } else if (l2 == null && l1!= null){
            // 如果链表2为空，链表1不为空，则直接将合并节点指向链表1的节点
            mergeList.next = l1;
        }
        return preHead.next;
    }

    public static void main(String[] args) {
        ListNode listNode = new ListNode(1);
        ListNode listNode1 = new ListNode(2);
        ListNode listNode2 = new ListNode(3);
        ListNode listNode3 = new ListNode(4);
        ListNode listNode4 = new ListNode(5);
        ListNode listNode5 = new ListNode(6);
        listNode.next = listNode2;
        listNode2.next = listNode4;

        listNode1.next = listNode3;
        listNode3.next = listNode5;
        ListNode resultNode = mergeTwoLists(listNode, listNode1);
        print(resultNode);
    }

    /**
     * 遍历链表
     */
    public static void print(ListNode node) {
        if (node == null)
            return;
        ListNode printNode = node;
        while (printNode != null) {
            System.out.print(printNode.val + " ");
            printNode = printNode.next;
        }
        System.out.println();
    }
}
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

解法2 递归方式

其实上面的过程就是通过不断比较两个链表的值，过程基本都是重复的，所以用递归也可以实现；

/**
 *  递归方式
 * @param l1
 * @param l2
 * @return
 */
public ListNode mergeTwoLists1(ListNode l1, ListNode l2) {
    if(l1 == null){
        return l2;
    }
    if(l2 == null){
        return l1;
    }
    if(l1.val <= l2.val){
        l1.next = mergeTwoLists1(l1.next,l2);
        return l1;
    }else{
        l2.next = mergeTwoLists1(l2.next,l1);
        return l2;
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21