每一步向前都是向自己的梦想更近一步，坚持不懈，勇往直前！
第一题：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;
}
}
