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