【java算法专场】滑动窗口（上）

滑动窗口

基本概念

滑动窗口(同向双指针）是一种基于双指针的一种思想，两个指针之间构成了一个窗口。

类型：窗口一般分为两类：一、固定大小的窗口；二、大小动态变化的窗口。

适用场景：

给的数据结构是数组/字符串；
求子数组/字符子串的最长最短等最值问题或者是在某个目标值时；
问题本身是可以通过暴力求解。

下面通过一些题目，来加深对滑动窗口的理解。

长度最小的子数组

算法分析

这道题其实就是要找一个连续的最短子数组，且这个子数组中所有元素之和要大于等于目标值target。如果使用暴力枚举每一个子数组的话，时间复杂度就会达到O(N^2),这道题的话，有更好的方法，那就是使用滑动窗口，接下来就解析一下如何使用滑动窗口来解这道题。

算法步骤

初始化双指针：设置两个指针left和right并初始化为0，表示窗口的左右边界。设置一个sum并初始化为0，用于计算窗口中所有元素之和。设置min并初始化为Integer.MAX_VALUE,用于记录符合目标的最小连续数组长度。
右边界（right）移动：让right往右移动，并nums[right]加入到sum中，这个过程相当于在扩大窗口的大小，让sum的值不断接近target。
更新min值：当sum的值大于等于target之后，利用min方法，更新min的值。
左边界（right）右移：当更新完min值之后，需要让left往右移，并且让sum减去nums[left]的值。这个过程相当于在缩小窗口。当sum的值比target小时，停止右移。
重复2-3-4操作：当走完步骤4之后，继续移动右边界，循环上述操作，直到right>nums.length。
返回min值：在返回min时，需要注意一下，可能数组中的所有元素相加都不能大于等于target，这时min依然是初始值，所以在返回时，需要判断一下min值。

时间复杂度：O(n),其中n为数组的长度,每个元素最多被遍历两次，第一次是扩大右边界时，第二次是左边界右移时。

空间复杂度：O(1),在算法中，只用了常数个变量。

示例

这里我们以第一个例子为例{2，3，1，4，3}，target=7

第一步：初始值

第二步：右边界右移

第三步：更新min值

此时min值为4

第四步：左边界右移

第五步：重复2-3-4步，直到遍历完整个数组

第六步：返回min值 【4，3】

算法代码

class Solution {public int minSubArrayLen(int target, int[] nums) {int left=0;int right=0;int sum=0;int min=Integer.MAX_VALUE;for(;right<nums.length;){//将窗口中的元素添加到sum中sum+=nums[right];//判断sum是否大于等于targetwhile(sum>=target){//将num[left]的值从sum从sum中减去sum-=nums[left];//更新最小长度min=Math.min(min,right-left+1);//左边界右移left++;}//扩大右边界right++;}//判断是否min大小，若是Integer.MAX_VALUE则返回0return min==Integer.MAX_VALUE?0:min;}
}

无重复字符的最长子串

算法分析

题目要求找不重复的最长子串的长度，如果直接暴力枚举出每一个子串，时间复杂度会达到O(n^2),这样的方法，可能会超时，所以，这道题我们可以使用滑动窗口还有哈希表来解决。

算法步骤

初始化变量：定义双指针left和right，并初始化为0。设置一个hash数组，用来模拟哈希表，【hash数组的大小根据ASCII码表，一共有128个字符，所以我们可以设置为128】。定义ans用来存储最长不重复子串的长度，并初始化为0.
右边界(right)移动：将right往右移动，在移动的过程中，每移动一次，就将ch[right]在hash中以ch[right]为下标的元素加1。
更新ans值：在右边界移动的过程中，每次都将ans的值进行更新。
处理重复字符：当right移动到某个位置之后，要将ch[right]在hash对应的位置元素+1，需要先判断当前位置元素是否大于1，若大于1，说明子串遇到了重复的字符，此时需要移动left指针，并将在hash中以ch[left]为下标的元素-1，同时left右移，直到将重复元素排除。
遍历结束：当right遍历完字符串，结束循环，并返回ans。

时间复杂度：O(n),n是字符串长度，在入窗口的时候，right遍历一遍，left在最坏情况下也只遍历一遍。

空间复杂度：O(1),用的都是固定大小的变量。

示例

以｛“abcabcbb”｝为例

第一步：初始化

int left=0,right=0
hash[] = new int[128];
int ans=0;
char ch={'a','b','c','a','b','c','b','b'};

第二、三步：右边界right右移，并且在right往右走的过程中，更新ans的值

第四步：处理重复字符

在上图中，第5个图，就是进行去重的情况。

第五步：重复上述操作，直到right到字符串末尾。

算法代码

 /*** 计算给定字符串中最长无重复字符的子串的长度。* 通过维护一个滑动窗口，使用数组hash来记录窗口内每个字符出现的次数。* 当遇到重复字符时，缩小窗口的左边界，直到重复的字符不再出现在窗口内。* 在每次移动窗口右边界时，更新最长无重复子串的长度。** @param s 输入的字符串* @return 最长无重复字符子串的长度*/public int lengthOfLongestSubstring(String s) {// 初始化最长长度为0int ans = 0;// 初始化窗口的左右边界int left = 0;int right = 0;// 将字符串转换为字符数组，方便操作char[] ch = s.toCharArray();// 创建一个数组作为简化版的哈希表，用于记录字符出现的次数int[] hash = new int[128];// 遍历字符数组for (; right < ch.length; right++) {// 将当前字符的出现次数加1hash[ch[right]]++;// 当当前字符出现次数大于1时，说明遇到了重复字符while (hash[ch[right]] > 1) {// 将窗口左边界右移，并将左边界字符的出现次数减1hash[ch[left++]]--;}// 更新最长无重复字符子串的长度// 更新ansans = Math.max(ans, right - left + 1);}// 返回最长无重复字符子串的长度return ans;}

最大连续1的个数 III

算法分析

这道题给定了一个只有0和1的数组，且给定允许改变数组中k个0，通过改变数组中k个0来得到一个最长连续1。如果我们使用暴力枚举的话，时间复杂度会达到O(n^2),可能会超时。我们可以使用滑动窗口以及给其外加一个计零器来解决。

算法步骤

初始化：定义两个指针left和right并初始化为0。设置一个zero作为计零器并初始化为0.设置一个ans并初始化为0，用来记录最长1的长度。
扩大窗口：右边界right往右移，并判断nums[right]是不是0，若是0，则zero++。
左边界右移：当zero大于k时，说明此时在窗口内的0大于k，要进行出窗口，直到zero=k。
更新ans:在right往右移的过程中，每次都需要更新ans值。
循环操作：重复2-3-4操作
遍历结束：直到right走到数组末尾，结束遍历，返回ans。

时间复杂度：0(n),n是数组长度，在整个过程中，进窗口的时候，right遍历一遍数组，出窗口的时候，最坏的情况下，left遍历一遍数组。

空间复杂度：0(1),在算法中，只用到了几个变量。

示例

以[1,1,1,0,0,0,1,1,1,1,0]，K=2为例，

第一步：初始化

left=0，right=0；
zero=0，ans=0；

第二步：右边界移动

让right往右移

第三步:左边界右移，直到zero=k

第四步：重复上述操作

第五步：当right遍历完数组，此时返回结果即可。由图可知，最长连续1的个数为6.

算法代码

class Solution {/*** 在给定数组中找到最长的子数组，该子数组中的0和1的个数之和不超过k。* 该方法通过滑动窗口算法实现，避免了重复计算，提高了效率。* * @param nums 输入的整数数组，其中包含0和1。* @param k 允许的0和1的个数之和的最大值。* @return 返回满足条件的最长子数组的长度。*/
public int longestOnes(int[] nums, int k) {/* 初始化最长子数组的长度为0 */int ans = 0;/* 初始化滑动窗口的左边界 */int left = 0;/* 初始化滑动窗口的右边界 */int right = 0;/* 初始化窗口中0的个数 */int zero = 0;/* 遍历数组，移动右边界 */for (; right < nums.length; right++) {/* 如果当前元素为0，增加窗口中0的个数 */if (nums[right] == 0) {zero++;/* 如果窗口中0的个数超过了k，移动左边界，减少窗口中0的个数 */while (zero > k) {if (nums[left++] == 0) {zero--;}}}/* 更新最长子数组的长度 *///更新ans值ans = Math.max(ans, right - left + 1);}/* 返回最长子数组的长度 */return ans;
}
}

将 x 减到 0 的最小操作数

算法分析

这道题如果我们按着它所给题意来做的话，是很困难的。题意就是想要让我们在数组两边进行操作，然后找两侧的数与x抵消之后让x为0。所以，我们可以采用正难则反的思想，既然是要求两侧的数之和能与x抵消，那么我们可以想象成就是要就是要在数组中找除了x之外，其他数之和的长度。最后让数组长度（len）减去其他数之和的长度，最终得到的就是我们想要能让x减为0的长度。

算法步骤

初始化：定义两个指针left和right，表示滑动窗口的两个边界。定义sum并初始化为0，用于记录滑动窗口中元素之和；定义target并初始化为0，用于后续记录数组中除了x之外其他数之和；定义ans并初始化为-1，用于数组中是否存在能让x为0的数，若没有则返回-1。
判断target：先将数组中所有的数加到target中，再让target减去x，并且判断此时target是否大于0，若小于0，说明数组中所有数之和比x要小，则直接返回-1.
扩大窗口：让right往右移动，并将nums[right]添加到sum中。
判断sum与target：若sum的值比target要大，说明此时需要缩小窗口，让sum减去nums[left]的值，并让left往右移动，直到sum不再大于target。
更新ans值:当sum的值与target相等，说明找到了一个符合条件的子数组，比较ans和right-left+1的大小，存放最大值在ans中。
重复：重复3、4、5操作，直到right走到数组末尾位置。
返回ans值：在返回值时，需要进行判断ans的大小，若ans=-1，说明数组不存在能让x为0的操作数；反之，则返回nums.length-ans的长度。

时间复杂度：O(n),n为数组长度，在入窗口的时候，right遍历一遍数组，在出窗口的时候，最坏情况下遍历一遍数组。

空间复杂度：O(1),只用了几个变量。

示例

以[1,1,4,2,3]，x=5为例

第一、二步：初始化，并将数组中所有元素添加到target，最后让target-x,判断target大小

target=1+1+4+2+3=11

target-5=6

第三、四步：扩大窗口，判断target与sum的大小

让right往右移动，并将nums[right]添加到sum中

第五步：更新ans值

在上图中，当right走到以2为下表的数时，此时sum与target相等，更新ans值

ans=Math.max(ans,right-left+1).,此时ans=3

第六步：重复上述操作。

第七步：返回ans值，当right遍历完数组之后，返回ans=3.

算法代码

/*** 计算最少操作次数，使得数组nums中的元素之和减去x后为0。* 操作包括将数组中的任意一个元素翻倍或减半。* * @param nums 输入的整数数组* @param x 需要减去的目标值* @return 返回最少操作次数，如果无法实现则返回-1*/
public int minOperations(int[] nums, int x) {// 初始化答案为-1，表示未找到符合条件的解int ans = -1;// 初始化左右指针和当前窗口内元素之和int left = 0;int right = 0;int sum = 0;// 计算目标值，即数组元素之和减去xint target = 0;for (int digit : nums) {target += digit;}target -= x;// 如果目标值小于0，说明无法通过操作达到目标，直接返回-1if (target < 0) return ans;// 遍历数组，寻找符合条件的最长子数组while (right < nums.length) {sum += nums[right];// 如果当前窗口内元素之和大于目标值，移动左指针缩小窗口while (sum > target) {sum -= nums[left++];}// 如果当前窗口内元素之和等于目标值，更新答案if (sum == target) {ans = Math.max(ans, right - left + 1);}right++;}// 根据答案计算并返回最终结果，如果答案为-1，则返回数组长度return ans == -1 ? -1 : nums.length - ans;
}

以上就是本篇所有内容，若有不足欢迎指正~