双指针+滑动窗口
双指针法
双指针法(快慢指针法): 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
-
快指针:寻找新数组的元素 ,新数组就是不含有目标元素的数组
-
慢指针:指向更新 新数组下标的位置1
for (int i = 0, j = 0; i < n; i ++ ) { while (j < i && check(i, j)) j ++ ; // 具体问题的逻辑 } 常见问题分类: (1) 对于一个序列,用两个指针维护一段区间 (2) 对于两个序列,维护某种次序,比如归并排序中合并两个有序序列的操作
- 移除元素
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
你不需要考虑数组中超出新长度后面的元素。
// 时间复杂度:O(n^2)
// 空间复杂度:O(1)
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int size = nums.size();
for (int i = 0; i < size; i++) {
if (nums[i] == val) { // 发现需要移除的元素,就将数组集体向前移动一位
for (int j = i + 1; j < size; j++) {
nums[j - 1] = nums[j];
}
i--; // 因为下标i以后的数值都向前移动了一位,所以i也向前移动一位
size--; // 此时数组的大小-1
}
}
return size;
}
};
977.有序数组的平方
给你一个按非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。
示例 1:
- 输入:nums = [-4,-1,0,3,10]
- 输出:[0,1,9,16,100]
- 解释:平方后,数组变为 [16,1,0,9,100],排序后,数组变为 [0,1,9,16,100]
class Solution {
public int[] sortedSquares(int[] nums) {
int n=nums.length;
int[] ans=new int[n];
for(int i=0,j=n-1,pos=n-1;i<=j;){
if(nums[i]*nums[i]>nums[j]*nums[j]){
ans[pos]=nums[i]*nums[i];
i++;
}else{
ans[pos]=nums[j]*nums[j];
j--;
}
pos--;
}
return ans;
}
}
滑动窗口
模板:
/* 滑动窗口算法框架 */
void slidingWindow(string s, string t) {
Map<Character, Integer> need = new HashMap<>();
Map<Character, Integer> window = new HashMap<>();
for (char c : t.toCharArray())
need.put(c,need.getOrDefault(c,0)+1);
int left = 0, right = 0;
int valid = 0;
while (right < s.size()) {
// c 是将移入窗口的字符
char c = s.charAt(right);
// 右移窗口
right++;
// 进行窗口内数据的一系列更新
...
/*** debug 输出的位置 ***/
System.out.println("window: ["+left+","+ right+")");
/********************/
// 判断左侧窗口是否要收缩
while (window needs shrink) {
// d 是将移出窗口的字符
char d = s[left];
// 左移窗口
left++;
// 进行窗口内数据的一系列更新
...
}
}
}
209.长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。
示例:
- 输入:s = 7, nums = [2,3,1,2,4,3]
- 输出:2
- 解释:子数组 [4,3] 是该条件下的长度最小的子数组。
class Solution {
// 滑动窗口
public int minSubArrayLen(int s, int[] nums) {
int left = 0;
int sum = 0;
int result = Integer.MAX_VALUE;
for (int right = 0; right < nums.length; right++) {
sum += nums[right];
while (sum >= s) {
result = Math.min(result, right - left + 1);
sum -= nums[left++];
}
}
return result == Integer.MAX_VALUE ? 0 : result;
}
}
//前缀和+二分
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int n=nums.length;
if(n==0){
return 0;
}
int ans=Integer.MAX_VALUE;
int[] sums=new int[n+1];
for(int i=1;i<=n;i++){
sums[i]=sums[i-1]+nums[i-1];
}
for(int i=1;i<=n;i++){
int s=target+sums[i-1];
int bound=Arrays.binarySearch(sums,s);
if(bound<0){
bound=-bound-1;
}
if(bound<=n){
ans=Math.min(ans,bound-(i-1));
}
}
return ans==Integer.MAX_VALUE?0:ans;
}
}
力扣76.最小覆盖子串题解
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串,则返回空字符串 。
class Solution {
public String minWindow(String s, String t) {
//1.维护两个map记录窗口中的符合条件的字符以及need的字符
Map<Character,Integer> window = new HashMap<>();
Map<Character,Integer> need = new HashMap<>();//need中存储的是需要的字符以及需要的对应的数量
for(char c : t.toCharArray())
need.put(c,need.getOrDefault(c,0)+1);
int left = 0,right = 0;//双指针
int count = 0;//count记录当前窗口中符合need要求的字符的数量,当count == need.size()时即可shrik窗口
int start = 0;//start表示符合最优解的substring的起始位序
int len = Integer.MAX_VALUE;//len用来记录最终窗口的长度,并且以len作比较,淘汰选出最小的substring的len
//一次遍历找“可行解”
while(right < s.length()){
//更新窗口
char c = s.charAt(right);
right++;//窗口扩大
// window.put(c,window.getOrDefault(c,0)+1);其实并不需要将s中所有的都加入windowsmap,只需要将need中的加入即可
if(need.containsKey(c)){
window.put(c,window.getOrDefault(c,0)+1);
if(need.get(c).equals(window.get(c))){
count++;
}
}
//System.out.println****Debug位置
//shrink左边界,找符合条件的最优解
while(count == need.size()){
if(right - left < len){//不断“打擂”找满足条件的len最短值,并记录最短的子串的起始位序start
len = right - left;
start = left;
}
//更新窗口——这段代码逻辑几乎完全同上面的更新窗口
char d = s.charAt(left);
left++;//窗口缩小
if(need.containsKey(d)){
//window.put(d,window.get(d)-1);——bug:若一进去就将window对应的键值缩小,就永远不会满足下面的if,while也会一直执行,知道left越界,因此,尽管和上面对窗口的处理几乎一样,但是这个处理的顺序还是很关键的!要细心!
if(need.get(d).equals(window.get(d))){
count--;
}
window.put(d,window.get(d)-1);
}
}
}
return len == Integer.MAX_VALUE ? "" : s.substring(start,start+len);
}
}