前言:学生时代参加过ACM训练队,校招时也刷过leetcode,年轻时做事情没有定性,每次都是遇到问题了,挑一些相关的题目练手。
也没有持续坚持下来。工作多年,反思个人专业素养需要持续提高,这样才能应对更具挑战的任务。先定下一阶段目标,持续20周(共140天计划) ,每周刷5道题。为了防止以后遇到与刷过的同类型题目不能在短时间内找到思路,每次刷完5道题目,将学习成果沉淀下来,方便自己未来查缺补漏。
1 两数之和 [简单]
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
思路:使用Map<Integer, List> map 将nums数组重新存储,map中的key是数组每个元素的值,value是一个list,存储相同值得index,使用一个list是为了应对数据具有多个相同值得情况。
package leetcode.lc001;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
class Solution {
public int[] twoSum(int[] nums, int target) {
/**
* key : 数组元素值
* value: 元素下标list
*/
Map<Integer, List<Integer>> map = new HashMap();
for (int i = 0; i < nums.length; i++) {
if (map.get(nums[i]) == null) {
ArrayList<Integer> is = new ArrayList<>();
is.add(i);
map.put(nums[i], is);
} else {
map.get(nums[i]).add(i);
}
}
for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
int add1 = entry.getKey();
int add2 = target - add1;
if (map.get(add2) != null) {
int[] result = new int[2];
// 两个加数相等
if (add1 == add2) {
if (map.get(add2).size() > 1) {
result[0] = map.get(add2).get(0);
result[1] = map.get(add2).get(1);
}
} else {
int idx1 = map.get(add1).get(0);
int idx2 = map.get(add2).get(0);
result[0] = Math.min(idx1, idx2);
result[1] = Math.max(idx1, idx2);
}
return result;
}
}
return null;
}
}
2 两数相加 [简单]
给你两个非空的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储一位数字。
请你将两个数相加,并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外,这两个数都不会以 0 开头。
思路:本题是一个简单地单链表操作,首先将两个单链表的同等地位的节点值相加,注意进位,最终将有多余高位的单链表节点值拷贝到结果链表中。
package leetcode.lc002;
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) {
ListNode result = new ListNode(); // 结果链表
ListNode cur_node = result; // 游动节点
ListNode pre_node = cur_node; // 当前节点的前一个节点,方便当结果链表最后一个节点值为null时,删除最后一个节点
int flag = 0; // 进位值
int sum = 0; // 同位置上的相加和
while (l1 != null && l2 != null) {
sum = l1.val + l2.val + flag;
cur_node.val = sum > 9 ? sum - 10 : sum;
flag = sum > 9 ? 1 : 0;
l1 = l1.next;
l2 = l2.next;
ListNode temp = new ListNode();
cur_node.next = temp;
pre_node = cur_node;
cur_node = temp;
}
while (l1 != null) {
sum = l1.val + flag;
cur_node.val = sum > 9 ? sum - 10 : sum;
flag = sum > 9 ? 1 : 0;
l1 = l1.next;
ListNode temp = new ListNode();
cur_node.next = temp;
pre_node = cur_node;
cur_node = temp;
}
while (l2 != null) {
sum = l2.val + flag;
cur_node.val = sum > 9 ? sum - 10 : sum;
flag = sum > 9 ? 1 : 0;
l2 = l2.next;
ListNode temp = new ListNode();
cur_node.next = temp;
pre_node = cur_node;
cur_node = temp;
}
if (flag > 0) {
cur_node.val = flag;
} else { // 将空节点删除
pre_node.next = null;
}
return result;
}
}
3 无重复字符的最长子串 [中等]
给定一个字符串 s ,请你找出其中不含有重复字符的最长子串的长度。
示例1:
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”,所以其长度为 3。
示例 2:
输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”,所以其长度为 1。
示例 3:
输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是"wke",所以其长度为 3。
请注意,你的答案必须是 子串 的长度,"pwke"是一个子序列,不是子串。
思路:
1、可以穷举字符串中的每一个子字符串,然后判断每一个子字符串的长度和是否有重复字符,然后将最长的没有重复字符的字符串返回。
2、在字符长上搞一个滑动窗口,如果新添加进来的字符不和已存在的字符相同,则滑动窗口的right向右边移动一位,如果造成重复,则当前字符串就不满足了,需要将left向右边移动一位(去掉最最左边字符)。
package leetcode.lc003;
import java.util.LinkedHashMap;
import java.util.Map;
public class Solution {
public int lengthOfLongestSubstring(String s) {
if (s == null || s == "") {
return 0;
}
int maxLen = 0;
/**
* key: 字符串中每个位置上的值
* value: 值对应的索引位
*/
Map<Character, Integer> map = new LinkedHashMap<>();
int end = 0; // 记录尝试添加到新字符串中的字符位置,如果添加之后有重复,下一个字符串从新尝试添加该索引位的字符
for (int left = 0; left < s.length(); left++) {
for (int right = end; right < s.length(); right++) {
map.put(s.charAt(right), right);
end = right;
// 添加新字符之后,与之前添加的字符有重复 或者 添加到最后一个字符
if (map.size() != (right - left + 1) || end == s.length() - 1) {
if (maxLen < map.size()) {
maxLen = map.size();
}
break;
}
}
// map 中第一个字符没有被新添加的字符覆盖
if (map.get(s.charAt(left)) == left) {
map.remove(s.charAt(left));
}
}
return maxLen;
}
}
4. 寻找两个正序数组的中位数 【困难】
给定两个大小分别为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例 1:
输入:nums1 = [1,3], nums2 = [2]
输出:2.00000
解释:合并数组 = [1,2,3] ,中位数 2
示例 2:
输入:nums1 = [1,2], nums2 = [3,4]
输出:2.50000
解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5
思路:本题的难点在于时间复杂度限制在O(log (m+n)) ,很容易联想到二分法。
一组数有x数字,如果将该x个数字切分成两部分,共有x种切分方法,分别是{}|{m1…mx},{m1},{m2…mx},…{m1,mx-1}|{mx},{m1,mx}|{},上例表示分别在0,1,2…x处进行分割。
针对两组有序数组m,n,将两组数分别分割成两部分,分别表示mleft, mright, nleft, nright,要求左半部分和右半部分相等,或者左半部分比有半部分多一个,即|mleft + nleft| - |mright + nright| <=1。(1)
假设m是在i处分割,n在j处分割,还需要满足mi-1<=nj, nj-1<=mi
工式(1)分为两种情况,当|m| + |n|为奇数时,有
i
+
j
=
∣
m
∣
−
i
+
∣
n
∣
−
j
+
1
i+ j = |m|-i + |n| -j + 1
i+j=∣m∣−i+∣n∣−j+1即
i
+
j
=
∣
m
∣
+
∣
n
∣
+
1
2
i+j=\frac{|m|+|n|+1}{2}
i+j=2∣m∣+∣n∣+1
当|m| + |n|为偶数时
有
i
+
j
=
∣
m
∣
−
i
+
∣
n
∣
−
j
i+ j = |m|-i + |n| -j
i+j=∣m∣−i+∣n∣−j 即
i
+
j
=
∣
m
∣
+
∣
n
∣
2
i+j=\frac{|m|+|n|}{2}
i+j=2∣m∣+∣n∣
按条件|m| + |n|为偶数,为了和|m| + |n|为奇数情况统一,有
i
+
j
=
∣
m
∣
+
∣
n
∣
2
=
∣
m
∣
+
∣
n
∣
+
1
2
i+j=\frac{|m|+|n|}{2}=\frac{|m|+|n|+1}{2}
i+j=2∣m∣+∣n∣=2∣m∣+∣n∣+1
为了满足(1)的同时满足(2),假设在满足(1)的情况下找到一个最大的i满足 mi-1<=nj,
按上述假设在i+1处分割m,就不会满足mi<=nj-1,必有 nj-1 < mi
综上,使用二分法,找到最大的i满足公式(1)、公式(2)即可
package leetcode.lc004;
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int len1 = nums1.length;
int len2 = nums2.length;
int[] temp = null;
if (len1 > len2) {
return findMedianSortedArrays(nums2, nums1);
}
int i = 0;
int j = 0;
int start = 0, end = len1;
int left_max = 0;
int right_min = 0;
// 二分查找的目的是为了找一个最大的i满足
// nums1_left_right <= nums2_right_left
// nums2_left_right <= nums1_right_left
while (start <= end) {
// 不写成 (start+end)/2是为了防止内存溢出
i = start + (end - start) / 2;
j = len1 + (len2 + 1 - len1) / 2 - i;
// nums1 左半部分最右边的数
int nums1_left_right = (i == 0 ? Integer.MIN_VALUE : nums1[i - 1]);
// nums1 右半部分最左边的数
int nums1_right_left = (i == len1 ? Integer.MAX_VALUE : nums1[i]);
// nums2 左半部分最右边的数
int nums2_left_right = (j == 0 ? Integer.MIN_VALUE : nums2[j - 1]);
// nums2 右半部分最左边的数
int nums2_right_left = (j == len2 ? Integer.MAX_VALUE : nums2[j]);
// nums1 最左边数比nums2 最右边数大
if (nums1_left_right <= nums2_right_left) {
left_max = Math.max(nums1_left_right, nums2_left_right);
right_min = Math.min(nums1_right_left, nums2_right_left);
start = i + 1;
} else {
end = i - 1;
}
}
return (len1 + len2) % 2 == 0 ? (left_max + right_min) / 2.0 : left_max;
}
}
测试用例
package leetcode.lc004;
import org.junit.Test;
public class Main {
Solution s = new Solution();
@Test
public void test01() {
int[] nums1 = {1, 3};
int[] nums2 = {2};
System.out.println(s.findMedianSortedArrays(nums1, nums2));
}
@Test
public void test02() {
int[] nums1 = {1, 2};
int[] nums2 = {3, 4};
System.out.println(s.findMedianSortedArrays(nums1, nums2));
}
@Test
public void test03() {
int[] nums1 = {1, 2};
int[] nums2 = {4, 5, 9};
System.out.println(s.findMedianSortedArrays(nums1, nums2));
}
@Test
public void test04() {
int[] nums1 = {2};
int[] nums2 = {};
System.out.println(s.findMedianSortedArrays(nums1, nums2));
}
}
5 最长回文子串 [中等]
给你一个字符串 s,找到 s 中最长的回文子串。
示例 1:
输入:s = “babad”
输出:“bab”
解释:“aba” 同样是符合题意的答案。
示例 2:
输入:s = “cbbd”
输出:“bb”
思路:动态规划,关键是找到状态转移方程,P(i,j)表示index起始点为i,结束点为j的子串是回文串。
那么有p(i,j) = p (i+1, j-1) && s[i] == s[j]
注意边界条件,当s[i] == s[j],si,j长度为2或者3时,直接判定时回文串,也就是j-i+1<=3,j-i<=2
当j-i>2时,则需要使用状态转移方程判断
以下是具体判断BABADABAC字符串回文状态表:
package leetcode.lc005;
class Solution {
public String longestPalindrome(String s) {
int len = s.length();
if (len < 2) {
return s;
}
int maxLen = 1;
int begin = 0;
boolean[][] dp = new boolean[len][len];
char[] charArray = s.toCharArray();
for (int i = 0; i < len; i++) {
dp[i][i] = true;
}
// 右边界
for (int right_index = 0; right_index < len; right_index++) {
// 左边界
for (int left_index = right_index; left_index >= 0; left_index--) {
if (charArray[left_index] == charArray[right_index]) {
if (right_index - left_index + 1 > 3 && !dp[left_index + 1][right_index - 1]) {
dp[left_index][right_index] = false;
} else {
dp[left_index][right_index] = true;
if (right_index - left_index + 1 > maxLen) {
begin = left_index;
maxLen = right_index - left_index + 1;
}
}
} else {
dp[left_index][right_index] = false;
}
}
}
for (int i = 0; i < dp.length; i++) {
for (int j = 0; j < dp[0].length; j++) {
System.out.print(dp[i][j] + "\t");
}
System.out.println();
}
return s.substring(begin, begin + maxLen);
}
}
package leetcode.lc005;
import org.junit.Test;
public class Main {
Solution s = new Solution();
@Test
public void test01() {
String str = "babad";
System.out.println(s.longestPalindrome(str));
}
@Test
public void test02() {
String str = "cbbd";
System.out.println(s.longestPalindrome(str));
}
@Test
public void test03() {
String str = "aaaa";
System.out.println(s.longestPalindrome(str));
}
}