算法入门第10天-递归/回溯(简单题2个)

1. leetcode 21 - 合并两个有序链表(简单)

1.1 题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.2 代码实现

参考官答：

思路1：递归

对于每个节点，当 l1 的节点值小于 l2 的值时， l1.next = mergeTwoLists (l1.next, l2)，即 l1 的next 指向l1.next 和 l2 合并后的节点。

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

时间复杂度：O(m+n)，最坏情况两个链表都要遍历1遍；
空间复杂度：O(m+n)。

思路2：迭代

设哨兵节点为合并后的链表的伪头节点，用于指向合并后节点，每次比较 l1 和 l2的节点值大小，并根据情况移动 哨兵节点及 l1 或 l2。
详见之前的文章：剑指 25. 合并两个有序链表 - 难度简单
时间：O(m+n)，空间：O(1)。

2. leetcode 206 - 反转链表(简单)

2.1 题目描述

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.2 代码实现

本次提交：使用迭代

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode pre = null;
        ListNode pos = null;
        while(head != null){
            pos = head.next;
            head.next = pre;
            pre = head;
            head = pos;
        }
        return pre;
    }
}

时间：O(n)，空间：O(1)。

回顾之前

详见剑指 24.反转链表 - 难度简单