避免重复刷题每次都两眼一抹黑咩都不记得,简单记一下思路。大概每天*10的进度。
1. 两数之和(简单)
题目:
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
输入:nums = [3,2,4], target = 6
输出:[1,2]
输入:nums = [3,3], target = 6
输出:[0,1]
思路:哈希表
遍历数组,若此时哈希表中有有当前元素的另一半,直接返回;
若没有,将当前元素存入哈希表。
其中哈希表的结构,以数组元素为索引(因为是不重复的),数组元素对应的下标作值。
注意要求返回的是数组的下标,不然Hashset就行。
class Solution {
public int[] twoSum(int[] nums, int target) {
HashMap<Integer,Integer> hash = new HashMap<>();
for(int i = 0;i < nums.length;i++){
if(hash.containsKey(target - nums[i]))
return new int[]{i, hash.get(target - nums[i])};
else
hash.put(nums[i],i);
}
return new int[]{};
}
}
2. 两数相加(中等)
题目:给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。
请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外,这两个数都不会以 0 开头。
输入:l1 = [2,4,3], l2 = [5,6,4]
输出:[7,0,8]
解释:342 + 465 = 807.
输入:l1 = [0], l2 = [0]
输出:[0]
输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出:[8,9,9,9,0,0,0,1]
思路:
就是链表遍历吧,注意一下进位和链表长度不等时多出来的部分。
流程就是遍历两个链表,注意记录进位,然后当一个链表指针指向空时,作为零值计算。
一些注意点见注释。
/**
* 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) {
ListNode p = new ListNode(0); //指向头结点
ListNode q = p; //遍历结果链表的指针
int m = 0; //进位
while (l1 != null || l2 != null || m != 0){ //这里容易忘记链表遍历完但是还有进位的情况
int l1_nunm = l1 != null ? l1.val : 0;
int l2_nunm = l2 != null ? l2.val : 0;
int sum = l1_nunm + l2_nunm + m;
m = sum / 10;
sum = sum % 10;
ListNode s = new ListNode(sum);
q.next = s;
q = q.next;
//这里注意判断条件是l1!=null而不是l1.next,因为必须到指向null,作为零值
if(l1 != null) l1 = l1.next;
if(l2 != null) l2 = l2.next;
}
return p.next;
}
}
3. 无重复字符的最长子串(中等)
题目:给定一个字符串 s
,请你找出其中不含有重复字符的 最长子串 的长度。
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。
输入: s = ""
输出: 0
思路:滑动窗口
遍历元素,当前元素已出现时,可能需要移动左边界。
至于为什么是可能,因为元素是以hashmap存储的,在此过程中map里不删,所以有可能遍历到的元素是在left边界之前出现过的,并不影响当前在计算的子串。设查找到的已存在元素位于j处。
因此需要判断,这个已经在map里的元素是不是比left小,若该重复元素确实在边界以内,则需要移动边界至j+1,并将该元素的位置更新为i,保证子串内只有一个这个元素。
长度的计算通过i和left就行。
class Solution {
public int lengthOfLongestSubstring(String s) {
HashMap<Character,Integer> hash = new HashMap<>();
int max = 0;
int left = 0;
for(int i = 0;i < s.length();i++){
if(hash.containsKey(s.charAt(i))){ //已经出现过
left = Math.max(left, hash.get(s.charAt(i)) + 1);
}
hash.put(s.charAt(i),i);
max = Math.max(max, i - left + 1);
}
return max;
}
}
4. 寻找两个正序数组的中位数(困难)
之前做的,这一次先不看困难的,回头再说
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int p = 0;
int q = 0;
boolean flag = true;
double x = 0,y = 0;
if ((nums1.length + nums2.length)%2 == 0)
flag = false;
int m = (nums1.length + nums2.length)/2;
for(int i = 0;i <= m ;i++){
x = y;
if(p == nums1.length)
y = nums2[q++];
else if (q == nums2.length)
y = nums1[p++];
else if(nums1[p] <= nums2[q])
y = nums1[p++];
else
y = nums2[q++];
}
if(!flag)
x = (x + y)/2;
else
x = y;
return x;
}
}
5. 最长回文子串(中等)
题目:给你一个字符串 s
,找到 s
中最长的回文子串。
输入:s = "babad"
输出:"bab"
解释:"aba" 同样是符合题意的答案。
输入:s = "cbbd"
输出:"bb"
输入:s = "a"
输出:"a"
输入:s = "ac"
输出:"a"
思路:
回文,即正反序相同。
中心扩散法。即以中心位置向两边发散,直至找到最大长度。
先向左找和中心元素一样的,再向右找和中心元素一样的,再同时向两边扩展。
不是最优解法,只是比较好理解。
class Solution {
public String longestPalindrome(String s) {
if(s.isEmpty() || s.length() < 2){
return s;
}
int left_max = 0;
int right_max = 0;
int len_max = 1;
boolean[][] dp = new boolean[s.length()][s.length()];
for (int i = 1; i < s.length(); i++){
int left = i - 1;
int right = i + 1;
int len = 1;
while (left >= 0 && s.charAt(left) == s.charAt(i)){
left--;
len++;
}
while (right <= s.length() - 1 && s.charAt(right) == s.charAt(i)){
right++;
len++;
}
while (left >= 0 && right <= s.length() - 1 && s.charAt(left) == s.charAt(right)){
left--;
right++;
len += 2;
}
if(len > len_max){
left_max = left;
len_max = len;
}
}
return s.substring(left_max + 1,left_max + len_max + 1);
}
}
10. 正则表达式匹配(困难)
暂略
11. 盛最多水的容器(中等)
题目:给你 n 个非负整数 a1,a2,...,an,每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线,使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明:你不能倾斜容器。
输入:[1,8,6,2,5,4,8,3,7]
输出:49
解释:图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。
之前做过一次。
思路大概是不断收缩长度,并且向短板的那边收缩。
应该不是最优。
class Solution {
public int maxArea(int[] height) {
int left = 0;
int right = height.length - 1;
int max_v = 0;
while (left < right){
int v = Math.min(height[left],height[right]) * (right - left);
max_v = v > max_v ? v : max_v;
if(height[left] < height[right]) //左边界是短板
left++;
else
right--;
}
return max_v;
}
}
15. 三数之和(中等)
题目:给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有和为 0 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
思路:排序,遍历数组,配合双指针,双指针分别指向剩余数组的左右边界
若和为0 ,返回;
若和小于0,是左边界太小了,左边界++;
若和大于0,是右边界太大了,右边界--。
注意由于要找的是不重复的,所以遍历的元素不能和上一个相同,找到一组之后要把左右边界都移动到元素不重复的位置。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List res = new ArrayList();
Arrays.sort(nums);
for(int i = 0;i < nums.length - 1;i++){
if(i > 0 && nums[i] == nums[i - 1]) continue;
int left = i + 1;
int right = nums.length - 1;
while (left < right){
int sum = nums[i] + nums[left] + nums[right];
if(sum == 0){ //找到了
List<Integer> list = new ArrayList();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
res.add(list);
//注意以下,要跳过重复的元素
while (left < right && nums[left] == nums[left+1]) left++;
while (left < right && nums[right] == nums[right - 1]) right--;
//然后这个重复的其实已经计算过了,下一个
left++;
right--;
}
else if(sum < 0) //左边界值太小
left++;
else //右边界值太大
right--;
}
}
return res;
}
}
17. 电话号码的字母组合(中等)
题目:
给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。
输入:digits = "23"
输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]
思路:排列组合问题,递归。
解法不太优。
class Solution {
private String[] nummap = {
" ", //0
"", //1
"abc", //2
"def", //3
"ghi", //4
"jkl", //5
"mno", //6
"pqrs", //7
"tuv", //8
"wxyz" //9
};
private ArrayList<String> res;
public List<String> letterCombinations(String digits) {
res = new ArrayList<String>();
if(digits.isEmpty()) return res;
findCombination(digits,0,""); //index标记找到digits哪一位了,s是当前的结果序列
return res;
}
private void findCombination(String digits, int index, String s){
if(index == digits.length()){ //根据index判断是否找完digits了,若找完,s就是这次的结果
res.add(s);
return;
}
String code = nummap[digits.charAt(index) - '0']; //取出本次要处理的字母
for(int i = 0;i < code.length();i++){
findCombination(digits, index + 1, s + code.charAt(i)); //把当前字母加进去,找下一位数字
}
}
}
19. 删除链表的倒数第 N 个结点(中等)
题目:给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。
进阶:你能尝试使用一趟扫描实现吗?
输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
思路:快慢指针。
两个指针之间相差n,快指针遍历完的时候,慢指针走到倒数第n个结点,即p指向最后一个结点时,q指向要删结点的上一个。
注意一下如果要删的点就是第一个结点的话,q指向的不是要删的上一个结点,需要直接操作head
/**
* 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 removeNthFromEnd(ListNode head, int n) {
ListNode p = head; //快
ListNode q = p; //慢
//让快指针先跑n
for(int i = 0;i < n;i++){
p = p.next;
}
//p跑完了,开始一起跑
if(p == null) //不用跑了,要删的就是第一个元素
return head.next;
while (p.next != null){
p = p.next;
q = q.next;
}
p = q.next.next;
q.next.next = null;
q.next = p;
return head;
}
}
21. 合并两个有序链表(简单)
题目:将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]
思路:递归
终止条件:当两个链表都为空。
如何递归:判断 l1 和 l2 头结点哪个更小,然后较小结点的 next 指针指向其余结点的合并结果,返回这个较小的结点给上一层进行连接。
注意一个为空了之后要返回另一个链表继续递归,直至两个链表都为空。
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if(l1 == null) return l2;
else if(l2 == null) return l1;
else if(l1.val <= l2.val){
l1.next = mergeTwoLists(l1.next,l2);
return l1;
}
else{
l2.next = mergeTwoLists(l2.next,l1);
return l2;
}
}
}
22. 括号生成(中等)
题目:数字 n 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。
输入:n = 3
输出:["((()))","(()())","(())()","()(())","()()()"]
输入:n = 1
输出:["()"]
(一开始还没看懂怎么这么多括号,后来才发现结果是String数组的意思……)
思路:dfs
左右括号数量相同。终止条件是左右括号都没有了。
对于有左括号的情况,优先添加左括号。左括号多于右括号时,可以添加右括号。
class Solution {
List<String> res = new LinkedList<>();
public List<String> generateParenthesis(int n) {
dfs(n, n, "");
return res;
}
private void dfs(int left, int right, String str){
if(left == 0 && right == 0){
res.add(str);
return;
}
if(left > 0)
dfs(left - 1, right, str + "(");
if(right > left)
dfs(left, right - 1, str + ")");
}
}
23. 合并K个升序链表(困难)
暂略
31. 下一个排列(中等)
题目:实现获取 下一个排列 的函数,算法需要将给定数字序列重新排列成字典序中下一个更大的排列(即,组合出下一个更大的整数)。
如果不存在下一个更大的排列,则将数字重新排列成最小的排列(即升序排列)。
必须 原地 修改,只允许使用额外常数空间。
输入:nums = [1,2,3]
输出:[1,3,2]
思路:从后往前找,对于每一位,他后面有没有比他更大的可以替换过来。
注意交换后要将交换的高位后面排序,以及如果不存在要重新排序成最小序列。
因为题目中条件1 <= nums.length <= 100,因此可以将101作为是否找到了的标志。
class Solution {
public void nextPermutation(int[] nums) {
for(int i = nums.length - 2;i >= 0;i--){
int min = 101;
int k = 0;
for(int j = nums.length - 1;j > i;j--){
if(nums[j] > nums[i] &