算法-leetcode-链表问题- 21. 合并两个有序链表

14, 21. 合并两个有序链表

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

思路1:迭代

思路2: 递归

package com.shangguigu.dachang.algrithm.A05_linkedList;

/**
 * @author : 不二
 * @date : 2022/4/11-下午2:35
 * @desc : 21. 合并两个有序链表
 *
 **/
public class A49_mergeTwoLists {
    public static void main(String[] args) {
        ListNode l11 = new ListNode(1);
        ListNode l12 = new ListNode(2);
        ListNode l13 = new ListNode(4);
        l11.next = l12;
        l12.next = l13;

        ListNode l21 = new ListNode(1);
        ListNode l22 = new ListNode(3);
        ListNode l23 = new ListNode(4);
        l21.next = l22;
        l22.next = l23;

//        ListNode listNode = mergeTwoLists(l11, l21);
        ListNode listNode = mergeTwoLists_v2(l11, l21);
        System.out.println("结果是：" + listNode);

    }

    /**
     * 思路1：递归法
     * 这个每怎么理解上，道理知道，但是不怎么想得通
     */
    public static ListNode mergeTwoLists_v2(ListNode list1, ListNode list2){
        if (list1 == null) {
            return list2;
        }
        if (list2 == null) {
            return list1;
        }

        // 比较头节点
        if (list1.val <= list2.val) {
            list1.next = mergeTwoLists_v2(list1.next, list2);
            return list1;
        } else {
            list2.next = mergeTwoLists_v2(list1, list2.next);
            return list2;
        }
    }


    /**
     * 思路1：迭代法
     */
    public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {

        ListNode l1Pointer = list1;
        ListNode l2Pointer = list2;


        ListNode sentinal = new ListNode(Integer.MIN_VALUE);
        ListNode preNode = sentinal;

        // 遍历第一个链表
        while (l1Pointer != null && l2Pointer != null) {
            // 这里说明链表1指针指向的比较小
            if (l1Pointer.val <= l2Pointer.val) {
                // 如果preNode是MIN_VALUE，则说明和头部相同
                /*if (preNode.val == Integer.MIN_VALUE) {
                    // 说明一个节点都还没有关联上
                    // 把头部指向指针位置
                    sentinal.next = l1Pointer;
                    // 然后preNode指向指针位置，方便后续使用preNode接着指向下一个比较小的node
                    preNode = l1Pointer;
                } else {
                    // 走到这里，说明哨兵节点已经就位，这里只处理preNode节点即可
                    preNode.next = l1Pointer;
                    preNode = l1Pointer;
                }*/
                // System.out.println("----");

                // 其实不用在乎是不是哨兵节点，这里只处理preNode节点即可(因为默认preNode和哨兵节点是同一个)
                preNode.next = l1Pointer;
                preNode = l1Pointer;

                // 小的指针往后移动
                l1Pointer = l1Pointer.next;
            } else {
                /*if (preNode.val == Integer.MIN_VALUE) {
                    // 说明一个节点都还没有关联上
                    sentinal.next = l2Pointer;
                    preNode = l2Pointer;
                } else {
                    preNode.next = l2Pointer;
                    preNode = l2Pointer;
                }*/

                preNode.next = l2Pointer;
                preNode = l2Pointer;

                // 小的指针往后移动
                l2Pointer = l2Pointer.next;
            }
        }

        // 走到这里，说明肯定有一个链表已经走完。没有走完的链表直接放在后面即可
        if (l1Pointer != null) {
            preNode.next = l1Pointer;
        }

        // 走到这里，说明肯定有一个链表已经走完。没有走完的链表直接放在后面即可
        if (l2Pointer != null) {
            preNode.next = l2Pointer;
        }
        return sentinal.next;
    }
}