leetcode刷题日记

2. 两数相加

思路与算法

由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。

我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为：n1+n2+carry；其中，答案链表处相应位置的数字为 (n1+n2+carry)%10，而新的进位值为 (n1+n2+carry)/10。

如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 00 。

此外，如果链表遍历结束后，有 carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 初始化一个链表 head ：用来记录结果；tail：用来记录当前节点，方便往后循环
        ListNode head = null, tail = null;
        // 初始化进值为0
        int carry = 0;
        // 循环迭代
        while (l1 != null || l2 != null) {
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            if (head == null) {
                // 初始化时,长度为空，则 head = tail = new ListNode(sum % 10);
                head = tail = new ListNode(sum % 10);
            } else {
                // tail 拼接上当前值，重新赋值为tail
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            // 获取进位值
            carry = sum / 10;
            // 判断l1不为null,则后移一个next
            if (l1 != null) {
                l1 = l1.next;
            }
            // 判断l2不为null,则后移一个next
            if (l2 != null) {
                l2 = l2.next;
            }
        }
        // 当前 l1 和 l2 均为 null，判断进位值carry>0,则拼接到tail的下个节点（tail一直指的当前节点）
        if (carry > 0) {
            tail.next = new ListNode(carry);
        }
        return head;
    }

729. 我的日程安排表 I

实现一个 MyCalendar 类来存放你的日程安排。如果要添加的日程安排不会造成 重复预订 ，则可以存储这个新的日程安排。

当两个日程安排有一些时间上的交叉时（例如两个日程安排都在同一时间内），就会产生 重复预订 。

日程可以用一对整数 start 和 end 表示，这里的时间是半开区间，即 [start, end), 实数 x 的范围为， start <= x < end 。

实现 MyCalendar 类：

MyCalendar() 初始化日历对象。
boolean book(int start, int end) 如果可以将日程安排成功添加到日历中而不会导致重复预订，返回 true 。否则，返回 false 并且不要将该日程安排添加到日历中。
示例：

方法一：直接遍历
我们记录下所有已经预订的课程安排区间，当我们预订新的区间[start,end)时，此时检查当前已经预订的每个日程安排是否与新日程安排冲突。若不冲突，则可以添加新的日程安排。
对于两个区间 [s1, e1)和 [s2, e2)，如果二者没有交集，则此时应当满足 s1≥e 2或者s 2≥e1，这就意味着如果满足 s1 < e2并且s 2<e1，则两者会产生交集。

import java.util.ArrayList;
import java.util.List;

/**
 * 功能描述：
 *
 * @Auther: zhu
 * @Date: 2022/7/5
 * @Description:
 * @Version:
 */
public class MyCalendar {
    List<int[]> books;

    public MyCalendar() {
        books = new ArrayList<int[]>();
    }

    public boolean book(int start, int end) {
        for (int[] arr : books) {
            int left = arr[0], right = arr[1];
            if (left < end && right > start) {
                return false;
            }
        }
        books.add(new int[]{start, end});
        return true;
    }
}

3. 无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

解析：在每一步的操作中，我们会将左指针向右移动一格，表示 我们开始枚举下一个字符作为起始位置，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。在移动结束后，这个子串就对应着 以左指针开始的，不包含重复字符的最长子串。我们记录下这个子串的长度；在枚举结束后，我们找到的最长的子串的长度即为答案。

    public int lengthOfLongestSubstring(String s) {
        // 存放已经遍历出现的元素
        HashSet<Character> set = new HashSet<>();
        // 长度赋值为0. end:最大子串的右边界
        int max = 0, end = 0;
        int n = s.length();
        // 从0坐标开始，遍历字符串
        for (int i = 0; i < n; i++) {
            // 当i>0时，左边界右移一位，移除最左边的已经不包含的字符，注意：i-1指的是左边界以外的字符
            if (i != 0) {
                set.remove(s.charAt(i - 1));
            }
            // 右边界end< n,且set中不包含该元素，则添加至set中
            while (end < n && !set.contains(s.charAt(end))) {
                set.add(s.charAt(end));
                end++; // 右边界一直在往后移动，为啥，每次循环end不是i+1开始,因为上次循环已经说明[i+1,end] 已经不存在重复元素
            }
            max = Math.max(max, end - i);
        }
        return max;
    }

5. 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

方法一：暴力破解

    public static String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }
        int tail = 1, start = 0;
        char[] chars = s.toCharArray();
        // 枚举所有长度大于1的字串
        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j < len; j++) {
                if (j - i + 1 > tail && isSonStr(chars, i, j)) {
                    tail = j - i + 1;
                    start = i;
                }
            }
        }
        return s.substring(start, start + tail);
    }

    public static boolean isSonStr(char[] chars, int left, int right) {
        while (left < right) {
            if (chars[left] != chars[right]) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

方法二：动态规划