码不停题：LeetCode 75-Day3【链表】

392. 判断子序列

❓题目描述

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

👉题目示例

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false

💡题目解析

题目中可以得到的信息：为t的子序列，且顺序不能变，按照t的字符顺序排列

💡思路1：利用双指针遍历

• 初始化双指针i和j，分别用于遍历字符串s和t
• 遍历的终止条件：i < s && j < t，不能超过字符串长度
• 若s的第i个字符等于t的某一个字符，则i++，s开始遍历第二个、第三个元素
• 不相等，则t一直遍历直到结束
• 是否为子字符串的条件：i==n，也就是s字符串遍历完了，存在相等

📝代码实现

📝思路1实现

class Solution {
    public boolean isSubsequence(String s, String t) {
        //获取字符长度
        int n = s.length(), m = t.length();
        //初始化遍历指针
        int i = 0, j = 0;
        //i 遍历对应 n , j -> m
        while(i < n && j < m){
            //s的第i个元素 == t的第j个元素，若相等，则s+1,s往后遍历
            if(s.charAt(i) == t.charAt(j)){
                i++;
            }
            // j往后遍历
            j++;
        }
        //是否遍历完
        return i == n;
    }
}

📈复杂度分析

时间复杂度：O(n+m)，其中 n 为 s 的长度，m 为 t 的长度。每次无论是匹配成功还是失败，都有至少一个指针发生右移，两指针能够位移的总距离为 n+m。

空间复杂度：O(1)。

合并两个有序链表

❓题目描述

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

👉题目示例

示例 1：

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

示例 2：

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

示例 3：

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

💡题目解析

从示例中得到的已知点

• l1为空，返回l2，反之则反

💡思路1：递归

• 比较list1的val和list2的val
• 如果list1.val < list2.val，则说明list1的元素比list2要小，递归遍历list1的下一个节点和list2比较，返回list1

💡思路2：遍历

• 遍历终止的条件为：list1和list2不为空时
• 初始化中间变量和返回结果
• 如果list1.val < list2.val，则说明list1的元素比list2要小，将中间变量的下一节点指向list，则list1 指向list1的下一节点
• 如果其中一个为空，中间变量则指向另一个节点，继续遍历

📝代码实现

📝思路1代码实现

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(null == list1){
            return list2;
        }
        if(null == list2){
            return list1;
        }
        //如果list1.val < list2.val 
        if(list1.val < list2.val){
            //说明list1元素比list2小，接着递归list1的下一节点
            list1.next = mergeTwoLists(list1.next, list2);
            return list1;
        }else{
            list2.next = mergeTwoLists(list2.next, list1);
            return list2;
        }
    }
}

📝思路2代码实现

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(null == list1){
            return list2;
        }
        if(null == list2){
            return list1;
        }
        //初始化返回结果
        ListNode result = new ListNode(0);

        ListNode pre = result;
        //变量list和list2，同时做比较
        while(null != list1 && null != list2){
            if(list1.val <= list2.val){
                pre.next = list1;
                list1 = list1.next;
            }else{
                pre.next = list2;
                list2 = list2.next;
            }
            pre = pre.next;
            //如果其中一个为空，则指向另一个节点，继续遍历
            if (list1 == null) {
                pre.next = list2;
            } else {
                 pre.next = list1;
            }
        }
        return result.next;
    }
}

📈复杂度分析

📈思路1复杂度

时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。

空间复杂度：O(1)。

📈思路2复杂度

时间复杂度：O(n)，其中 n 是链表的长度。需要对链表的每个节点进行反转操作。

空间复杂度：O(n)，其中 n是链表的长度。空间复杂度主要取决于递归调用的栈空间，最多为 n层