本文探讨了几个经典的编程问题，包括两数之和、无重复字符的最长子串、有效的括号验证以及二分查找。通过讲解这些题目，介绍了滑动窗口、哈希映射和双指针等技巧，并提供了详细的解题思路和代码实现。此外，还强调了在解决这类问题时，如何利用数据结构如栈的特性来简化问题。
| 字段1 | 字段1链接 | 难度 | 最近考察时间 | 考频 | 注释 |
|---|---|---|---|---|---|
| 1. 两数之和 | https://leetcode-cn.com/problems/two-sum | 容易 | 2021/4/24 | 8 | 这个题目1两数之和是题目15. 三数之和的变形的题目。开始的思路是：首先对数组进行排序，然后采用双指针的方法逼近结果。但是排序会改变数组的索引，而需要返回的结果就是数组的索引，这样是不行的。需要用hashmap。使用hashmap存储，key是nums[i]，val是i。 |
| 3. 无重复字符的最长子串 | https://leetcode-cn.com/problems/longest-substring-without-repeating-characters | 中等 | 2021/4/14 | 8 | 遇到子串问题，首先想到的就是滑动窗口技巧。滑动窗口也就是说，移动右指针，往窗口内添加数据，移动左指针去删除数据。另外注意hashmap的val=0时，是会占用空间的，需要手动remove（使用hashmap.size()作为返回结果时），要不然就使用right-left。 |
| 20. 有效的括号 | https://leetcode-cn.com/problems/valid-parentheses | 容易 | 2021/4/22 | 6 | 通过示例5"{[]}"，可以知道，这道题目需要借助栈的性质：先进后出。自己写的好复杂，不精练。常刷熟悉套路。细节上就是s.toCharArray()，Stackstack=new Stack<>();!stack.isEmpty()。最后判断栈是否为空，如果不是，例如还有‘｛[(’存在，说明还有剩余，则return false; |
| 704. 二分查找 | https://leetcode-cn.com/problems/binary-search | 容易 | 2021/4/20 | 6 | 在后端中考频占比很少。这个题目是二分查找的经典模板题目。 |
| 141. 环形链表 | https://leetcode-cn.com/problems/linked-list-cycle | 容易 | 2021/4/27 | 5 | 就是得背诵记忆，重复的去刷才行。经典解法就是用两个指针，一个跑得快，一个跑得慢。如果不含有环，跑得快的那个指针最终会遇到 null，说明链表不含环；如果含有环，快指针最终会超慢指针一圈，和慢指针相遇，说明链表含有环。 |
1. 两数之和
这个问题的最基本形式是这样：给你一个数组和一个整数 target，可以保证数组中存在两个数的和为 target，请你返回这两个数的索引。
对于 TwoSum 问题，一个难点就是给的数组无序。对于一个无序的数组，我们似乎什么技巧也没有，只能暴力穷举所有可能。
一般情况下，我们会首先把数组排序再考虑双指针技巧。TwoSum 启发我们，HashMap 或者 HashSet 也可以帮助我们处理无序数组相关的简单问题。
这个题目1两数之和是题目15. 三数之和的变形的题目。开始的思路是：首先对数组进行排序，然后采用双指针的方法逼近结果。但是排序会改变数组的索引，而需要返回的结果就是数组的索引，这样是不行的。需要用hashmap。使用hashmap存储，key是nums[i]，val是i。
代码：
class Solution {
public int[] twoSum(int[] nums, int target) {
// 使用hashmap存储，key是nums[i]，val是i
HashMap<Integer,Integer>map=new HashMap<>();
// 遍历数组元素
for(int i=0;i<nums.length;i++){
if(map.containsKey(target-nums[i])){
return new int[]{i,map.get(target-nums[i])};
}
// 存入hashmap，key是nums[i]，val是i
map.put(nums[i],i);
}
// 表示结果不存在
return new int[]{};
}
}
双指针不行
开始的思路是：首先对数组进行排序，然后采用双指针的方法逼近结果。但是排序会改变数组的索引，而需要返回的结果就是数组的索引，这样是不行的。
class Solution {
public int[] twoSum(int[] nums, int target) {
// 首先对数组进行排序，然后采用双指针的方法逼近结果
Arrays.sort(nums);
int left=0,right=nums.length-1;
while(left<right){
int sum=nums[left]+nums[right];
if(sum<target){
left++;
}else if(sum>target){
right--;
}else{
return new int[]{left,right};
}
}
return new int[]{};
}
}
3. 无重复字符的最长子串
遇到子串问题，首先想到的就是滑动窗口技巧。滑动窗口也就是说，移动右指针，往窗口内添加数据，移动左指针去删除数据。另外注意hashmap的val=0时，是会占用空间的，需要手动remove（使用hashmap.size()作为返回结果时），要不然就使用right-left。
牢记：伪码框架：
string s, t;
// 在 s 中寻找 t 的「最小覆盖子串」
int left = 0, right = 0;
string res = s;
while(right < s.size()) {
window.add(s[right]);
right++;
// 如果符合要求，移动 left 缩小窗口
while (window 符合要求) {
// 如果这个窗口的子串更短，则更新 res
res = minLen(res, window);
window.remove(s[left]);
left++;
}
}
return res;
类似之前的思路，使用 window 作为计数器记录窗口中的字符出现次数，然后先向右移动 right，当 window 中出现重复字符时，开始移动 left 缩小窗口，如此往复：
class Solution {
// 在这里的题目要求是：求取子串，子串是不能被分割开的。
public int lengthOfLongestSubstring(String s) {
// 定义一个返回的结果
int maxLen=0;
// 使用hashMap来避免结果中出现重复的字符
HashMap<Character,Integer>window=new HashMap<>();
// 使用双指针
int left=0,right=0;
// 大循环里面的遍历
while(right<s.length()){
// 取值
char c1=s.charAt(right);
right++;
// 存入window
window.put(c1,window.getOrDefault(c1,0)+1);
// 如果此时的字符重复，那就去移动指针
while(window.get(c1)>1){
// 去掉left所在的值
char c2=s.charAt(left);
left++;
window.put(c2,window.getOrDefault(c2,0)-1);
// 在这里要非常注意，value=0时，key并没有被清除。
if(window.get(c2).equals(0)){
window.remove(c2);
}
}
// 更新此时的长度
maxLen=Math.max(maxLen,window.size());
}
return maxLen;
}
}
class Solution {
public int lengthOfLongestSubstring(String s) {
int left = 0, right = 0;
HashMap<Character, Integer> window = new HashMap<>();
int resMaxLen = 0;
while (right < s.length()) {
char c1 = s.charAt(right);
window.put(c1, window.getOrDefault(c1, 0) + 1);
right++;
// 如果 window 中出现重复字符
// 开始移动 left 缩小窗口
while (window.get(c1) > 1) {
char c2 = s.charAt(left);
window.put(c2, window.getOrDefault(c2, 0) - 1);
left++;
}
resMaxLen = Math.max(resMaxLen, right - left);
}
return resMaxLen;
}
}
需要注意的是，因为我们要求的是最长子串，所以需要在每次移动 right 增大窗口时更新 res，而不是像之前的题目在移动 left 缩小窗口时更新 res。
20.有效的括号
通过示例5"{[]}"，可以知道，这道题目需要借助栈的性质：先进后出。自己写的好复杂，不精练。常刷熟悉套路。细节上就是s.toCharArray()，Stackstack=new Stack<>();!stack.isEmpty()。最后判断栈是否为空，如果不是，例如还有‘｛[(’存在，说明还有剩余，则return false;
//基本思想：每次遇到左括号时都将相对应的右括号'）'，']'或'}'推入堆栈
//如果在字符串中出现右括号，则需要检查堆栈是否为空，以及顶部元素是否与该右括号相同。如果不是，则该字符串无效。
//最后，我们还需要检查堆栈是否为空
class Solution {
public boolean isValid(String s) {
// 利用栈的性质，先入先出
Stack<Character>stack=new Stack<>();
// 遍历字符串的元素
for(char sc:s.toCharArray()){
if(sc=='{'){
stack.push('}');
}else if(sc=='['){
stack.push(']');
}else if(sc=='('){
stack.push(')');
}else if(!stack.isEmpty()&&sc==stack.peek()){
stack.pop();
}else{
return false;
}
}
// 最后判断栈是否为空，如果不是，例如还有‘｛[(’存在，说明还有剩余，则return false;
if(!stack.isEmpty()){
return false;
}
return true;
}
}
704. 二分查找
https://leetcode-cn.com/problems/binary-search
在后端中考频占比很少。这个题目是二分查找的经典模板题目。
class Solution {
public int search(int[] nums, int target) {
// 数组升序，所以就不用手动排序了,因为要返回下标，所以题目只能是已经排序好的了。
// 利用二分查找，这个题目是二分查找的经典模板题目
//左右边界
int left=0,right=nums.length-1;
while(left<=right){
//中点的索引
int mid=(right-left)/2+left;
if(nums[mid]<target){
// 将区间变为[mid+1,right]
left=mid+1;
}else if(nums[mid]>target){
// 将区间变为[left,mid-1]
right=mid-1;
}else if(nums[mid]==target){
// 找到了结果，返回结果下标
return mid;
}
}
// 不存在
return -1;
}
}
二分查找框架
int binarySearch(int[] nums, int target) {
int left = 0, right = ...;
while(...) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
...
} else if (nums[mid] < target) {
left = ...
} else if (nums[mid] > target) {
right = ...
}
}
return ...;
}
141. 环形链表
https://leetcode-cn.com/problems/linked-list-cycle
就是得背诵记忆，重复的去刷才行。经典解法就是用两个指针，一个跑得快，一个跑得慢。如果不含有环，跑得快的那个指针最终会遇到 null，说明链表不含环；如果含有环，快指针最终会超慢指针一圈，和慢指针相遇，说明链表含有环。
public class Solution {
public boolean hasCycle(ListNode head) {
ListNode fast=head,slow=head;
while(fast!=null&&fast.next!=null){
fast=fast.next.next;
slow=slow.next;
//两者相遇了
if(fast==slow){
return true;
}
}
return false;
}
}
扫一扫
2048
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
