每一步向前都是向自己的梦想更近一步，坚持不懈，勇往直前！

第一题：1. 两数之和 - 力扣（LeetCode）

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //返回值为Int[]数组，所以先初始化，求两数之和，使用空间换时间，用一个HashMap来存储
        int[] res = new int[2];
        Map<Integer, Integer> map = new HashMap<>();
        //对于每一个数都进行遍历，因为不知道到底哪个数是第一个数
        for(int i = 0; i < nums.length; i++){
            //每次计算一个差值
            int dif = target - nums[i];
            //key值找到了，取到的value，就是第一个数
            if(map.containsKey(dif)){
                //找到了，记录一下，不用在意先后顺序
                res[0] = map.get(dif);
                res[1] = i;
                //因为只有一组正确答案，所以有正确答案了就break
                break;
            }
            map.put(nums[i], i);
        }
        return res;
    }
}

---

第二题：2. 两数相加 - 力扣（LeetCode）

/**
 * 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 addTwoNumbers(ListNode l1, ListNode l2) {
        //讨论特殊情况，如果某一条是null，则直接返回另外一条
        if(l1 == null){
            return l2;
        }
        if(l2 == null){
            return l1;
        }
        //初始化一个头节点，注意要mod10
        ListNode node = new ListNode((l1.val + l2.val) % 10);
        //设置初始的进位位
        int carry = (l1.val + l2.val > 9) ? 1 : 0;
        //当前俩节点的值用过了，指向下一位
        l1 = l1.next;
        l2 = l2.next;
        //在正式开始前，首先创造一个dummy节点用于指向虚拟节点，这样返回的时候就直接返回dummy.next
        ListNode dummyhead = new ListNode(-1, node);
        //注意判断条件：只有进位位及两个链表都遍历完了才能结束
        while(l1 != null || l2 != null || carry != 0){
            //直接使用进位位carry来初始化当前的值，因为要么是0，要么是1
            int sum = carry;
            if(l1 != null){
                sum += l1.val;
                l1 = l1.next;
            }
            if(l2 != null){
                sum += l2.val;
                l2 = l2.next;
            }
            carry = sum / 10;
            //创建的节点与之前的节点相连
            node.next = new ListNode(sum > 9 ? sum % 10 : sum);
            //指向当前节点
            node = node.next;
        }
        return dummyhead.next;
    }
}

---

第三题：3. 两数相加 - 力扣（LeetCode）

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //如果长度为0或者1，直接返回自身长度就OK
        if(s.length() < 2){
            return s.length();
        }
        //便于方便，转为字符数组
        char[] words = s.toCharArray();
        //用数组来存一个字符的频率不方便，使用map来存最晚出现的下标
        Map<Character, Integer> map = new HashMap<>();
        //res是最长的长度，l是我们的左边区间
        int res = 0, l = 0;
        //对于每一个字符进行遍历
        for(int r = 0; r < words.length; r++){
            //当key值存在的时候，意味着有重复字符了，所以进行左边界的更新
            if(map.containsKey(words[r])){
                l = Math.max(l, map.get(words[r]) + 1);
            }
            //注意map的特性，如果对于已经存在的key进行put，会覆盖掉原来的值
            map.put(words[r], r);
            //每次都更新一下最大值
            res = Math.max(res, (r - l) + 1);
        }
        return res;
    }
}

---

第四题：4. 寻找两个正序数组的中位数 - 力扣（LeetCode）

public class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        //看到log的要求和有序，一定要想到二分，对于搜索，一个长度为n的有序数组可以看作一个BST，对于任意数的搜索，最大时间就是树高log(n)
        int m = nums1.length;
        int n = nums2.length;
        
        // 确保 nums1 是较短的数组
        if (m > n) {
            return findMedianSortedArrays(nums2, nums1);
        }
        
        int left = 0;
        int right = m;
        int partitionX, partitionY;
        
        while (left <= right) {
            // 在 nums1 上进行二分查找
            partitionX = (left + right) / 2;
            partitionY = (m + n + 1) / 2 - partitionX;
            
            // 计算划分两部分的最大值和最小值
            int maxX = (partitionX == 0) ? Integer.MIN_VALUE : nums1[partitionX - 1];
            int minX = (partitionX == m) ? Integer.MAX_VALUE : nums1[partitionX];
            int maxY = (partitionY == 0) ? Integer.MIN_VALUE : nums2[partitionY - 1];
            int minY = (partitionY == n) ? Integer.MAX_VALUE : nums2[partitionY];
            // 分类讨论
            // 判断是否满足条件
            if (maxX <= minY && maxY <= minX) {
                // 如果总元素数量为偶数，则取两个最大值和最小值的平均值
                if ((m + n) % 2 == 0) {
                    return (double) (Math.max(maxX, maxY) + Math.min(minX, minY)) / 2;
                } else {
                    // 如果总元素数量为奇数，则取较大的最大值
                    return (double) Math.max(maxX, maxY);
                }
            } else if (maxX > minY) {
                // 如果 maxX 大于 minY，说明划分位置过大，向左移动
                right = partitionX - 1;
            } else {
                // 如果 maxX 小于等于 minY，说明划分位置过小，向右移动
                left = partitionX + 1;
            }
        }
        throw new IllegalArgumentException("Input arrays are not sorted.");
    }
}

---

 第五题：5. 最长回文子串 - 力扣（LeetCode）

class Solution {
    public String longestPalindrome(String s) {
        //不使用dp了，直接使用中心扩散法，这样在遍历的过程可以直接降为一维的
        if (s == null || s.length() < 1) {
            return "";
        }
        int start = 0, end = 0; // 用于记录最长回文子串的起始和结束索引
        // 遍历每个字符，以该字符为中心向两边扩展，分别处理单个字符和两个字符为中心的情况
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i); // 以当前字符为中心的回文串长度
            int len2 = expandAroundCenter(s, i, i + 1); // 以当前字符和下一个字符为中心的回文串长度
            int len = Math.max(len1, len2); // 取两种情况下的最长回文串长度
            // 如果当前回文串长度大于之前记录的最长回文串长度，则更新起始和结束索引
            if (len > end - start) {
                start = i - (len - 1) / 2; // 计算起始索引
                end = i + len / 2; // 计算结束索引
            }
        }
        return s.substring(start, end + 1); // 返回最长回文子串
    }
    // 辅助方法：以left和right为中心向两边扩展，寻找最长回文串的长度
    private int expandAroundCenter(String s, int left, int right) {
        // 当左右指针合法且字符相等时，向两边扩展
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--; // 向左扩展
            right++; // 向右扩展
        }
        // 返回当前找到的回文串的长度
        return right - left - 1;
    }
}