C语言中的窗口滑动技术

学习文章：C语言中的窗口滑动技术

滑动窗口法#

  • C语言中的窗口滑动技术

循环几乎是每个复杂问题的一部分。太多的循环/嵌套循环会增加所需的时间，从而增加程序的时间复杂性。窗口滑动技术是一种计算技术，用于减少程序中使用的嵌套循环的数量，通过用单个循环代替嵌套循环来提高程序的效率。

如果你熟悉计算机网络中的滑动窗口协议，这种技术也很类似，本教程通过不同的例子解释了这种技术的使用方法。

一般来说，当我们使用这样的嵌套循环时 。

for(i = 1; i <= n; i++)
{
    for(j = i; j < k; j++)
    {
    }
}

迭代： 外循环执行n次；每执行一次外循环，内循环就执行（k−i）次。执行整个循环所需的平均时间大约为O(N2)。因此，开发人员不建议使用循环。

让我们举一个例子来清楚地理解这个概念 。

假设我们要找到一个数组中′k′个连续元素的最大和，用户提供k值：

首先，如果我们使用传统的方法，对于数组中的每个元素i，我们将从i+1到n−1遍历数组，其中n是数组的大小，我们需要对每个元素都这样做，然后比较总和，得到最大总和。

  • 暴力方法
#include<stdio.h>
int main()
{
/*
    找到一个数组中’k’个连续元素的最大和
*/
    int n, size, sum=0, max = 0, j;

    printf("Enter the size of the array: ");
    scanf("%d", &n);

    int arr[n], i;
    printf("Enter the elements of the array: ");
    for(i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
    }

    printf("Enter the size of sub-array: ");
    scanf("%d", &size);

    for(i = 0; i < (n - size) + 1; i++)
    {
        /*
            其实也是滑动窗口的思想
        */
        sum = 0;
        for(j = i; j < i + size; j++)
        {
            sum = sum + arr[j];
        }
        if(sum > max)
        {
            max = sum;
        }
    }
    printf("The maximum sum of %d consecutive elements of the array: %d\n", size, max);
}

输出 ：

Enter the size of the array: 10
Enter the elements of the array: 8 2 1 7 3 2 5 8 1 3
Enter the size of the sub-array: 3
The maximum sum of 3 consecutive elements of the array: 20

现在，滑动窗口技术来了

这里的概念是，我们创建一个大小为k的窗口，我们将通过一个单位指数不断地滑动它。在这里，窗口并不是什么技术术语。我们不是像在循环中那样使用一个单一的值，而是在每次迭代中同时使用多个元素。

比如说给定一个大小为10的数组：

C语言中的窗口滑动技术

假设我们需要3个连续索引的最大和，创建一个3个大小的窗口，并在整个数组中不断滑动（遍历）它。这里有一个形象的表示。

迭代1：

C语言中的窗口滑动技术

迭代2 :

C语言中的窗口滑动技术

迭代3：

C语言中的窗口滑动技术

迭代4：

C语言中的窗口滑动技术

迭代5：

C语言中的窗口滑动技术

迭代6：

C语言中的窗口滑动技术

迭代7：

C语言中的窗口滑动技术

迭代8：

C语言中的窗口滑动技术

  • 使用这种方法，将没有内循环，一个单循环的迭代次数将是(n–k+1)，在这种情况下是8。
  • 所以，滑动窗口是一种用于减少嵌套循环的技术，用一个单循环代替它，以减少总的时间复杂性。
  • 请注意，在每次迭代中，当窗口滑动到下一个索引时， 我们都会删除前一个窗口的第一个元素，并添加一个新的元素，即下一个继任索引。

下面是代码：

#include <stdio.h>

int maxsum(int a[], int k, int n);
int main()
{
    int n, i, k;

    printf("Enter the size of the array: ");
    scanf("%d", &n);
    int arr[n];
    printf("Enter the elements: ");

    for (i = 0; i < n; i++)
    {
        scanf("%d", &arr[i]);
    }
    printf("Enter the value of k: ");
    scanf("%d", &k);

    int max = maxsum(arr, k, n);
    printf("The maximum sum of %d consecutive elements in the array: %d\n", k, max);
}
int maxsum(int a[], int k, int n)
{
    int i, sum, maxm = 0;
    for (i = 0; i < k; i++)
    {
        maxm = maxm + a[i];     //记录第一个窗口元素和
    }
    sum = maxm;                 //初始化sum
    for (i = k; i < n; i++)
    {
        sum += a[i] - a[i - k]; //当窗口滑动到下一个索引时， 我们都会删除前一个窗口的第一个元素，并添加一个新的元素
        if (sum > maxm)
        {
            maxm = sum;
        }
    }
    return maxm;
}

输出：

Enter the size of the array: 10
Enter the elements: 8 2 1 7 3 2 5 8 1 3
Enter the value of k: 3
The maximum sum of 3 consecutive elements in the array: 15
  • 暴力方法在两个嵌套循环中需要O(k∗n)时间。
  • 通过使用滑动窗口技术，时间复杂度降低到O(n)。

以下是将该技术应用于手头任何问题的步骤：

  1. 首先，我们必须看到，窗口的大小是恒定的，不应该改变。我们可以只对这样的问题使用该技术。
  2. 在确保窗口大小没有变化后，计算第一个窗口的结果，与数组其他部分的计算结果进行比较。
  3. 现在，用一个循环来逐个滑动窗口的索引，直到最后，不断更新所需的值。

题目1#

3. 无重复字符的最长子串

image-20230404141552133

方法#

参考：无重复字符的最长子串--三种方法

  • 双层循环【暴力破解】

我们需要两层循环，第一层循环遍历字符串、并且记录第二层循环开始的位置。
①创建一个新的数组；
②从第一个字符开始遍历，不重复的字符就将它放到新的数组中，遇到重复的就停止，计算该子串的长度；
③开始下一次循环，直到遍历到字符串结束。

image-20230404150120890

代码：C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int lengthOfLongestSubstring(char *s)
{
    if (s == NULL) // 判断空指针
        return 0;

    int len = strlen(s);
    int maxlength = 0; // 记录最长长度

    int i = 0;
    for (i = 0; i < len; i++) // 外层循环遍历字符串
    {
        int curlength = 0; // 记录每一次的长度

        char *tmp = (char *)calloc(len, 1); // 用来存放子串
        int t = 0;

        int j = i;                         // 从i开始遍历
        while (s[j] && !strchr(tmp, s[j])) // 要防止子串出现越界情况
        {
            tmp[t++] = s[j++]; // 字符不存在就保存
        }
        curlength = t; // 子串的长度

        if (maxlength < curlength) // 找最长
        {
            maxlength = curlength;
        }
        free(tmp);
    }
    return maxlength;
}

int main()
{
    char *s = "abcabcdb";

    int k = lengthOfLongestSubstring(s);
    printf("k=%d\n", k);

    return 0;
}
  • 滑动窗口法

上面暴力破解的时间复杂度很高：O(n2)，我们可以发现内循环每进行一次都会有数据被重复移动，这个操作消耗了大量的时间，在「C语言中的窗口滑动技术」中，我们了解滑动窗口法可以减少循环次数，提升程序效率，下面我们通过滑动窗口的方法来进行化简。

image-20230404172210410

代码：C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int lengthOfLongestSubstring(char *s)
{
    if (s == NULL)
        return 0;

    int len = strlen(s);
    char *tmp = (char *)calloc(len, 1);
    int right = 0;     // 有效字符串长度
    int maxlength = 0; // 记录最长长度

    int i = 0;
    for (i = 0; i < len; i++)
    {
        char *p = strchr(tmp, s[i]);
        tmp[right] = s[i];    //先插入tmp
        right++;

        if (p) // 如果该字符已存在，就跳到该位置
        {
            right = right - (p - tmp) - 1; // 更新长度，指针相减（p - tmp）表示指针指向位置相隔的元素个数
            char *eff = (char *)malloc(right);
            // 跳过中间重复的部分
            memcpy(eff, p + 1, right);               // 先将有无重复的字符串保存
            memset(tmp, '0', (p - tmp + 1 + right)); // 清空原字符串
            memcpy(tmp, eff, right);                 // 将新字符串重新拷贝回去

            free(eff);
        }

        if (maxlength < right) // 找最长
        {
            maxlength = right;
        }
    }
    return maxlength;
}

int main()
{
    char *s = "abcabcdb";

    int k = lengthOfLongestSubstring(s);
    printf("k=%d\n", k);

    return 0;
}
  • 滑动窗口法（改进）

上面我们通过字符的复制和删除来省略了多次遍历的过程，不过，我们在删除字符的时候需要将后面全部的字符都往前移，这样也浪费一些时间，那么我们是否可以通过找到最长子串的具体位置，来省去删除字符的过程呢？答案肯定是可以的，下面就让我们开始实际操作。

image-20230404181241185

程序：C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int lengthOfLongestSubstring(char* s) {

	if (s == NULL)
		return 0;

	int len = strlen(s);
	char* tmp = (char*)calloc(len, 1);  
	int right = 0; // 当前字符串长度
	int left = 0; // 控制子串起始位置
	int maxlength = 0; // 记录最长长度

	for (int i = 0; i < len; i++)
	{
		char* p = strchr(tmp + left, s[i]);//这里需要注意的一点是字符必须先判断后复制

		tmp[right] = s[i];      //逐个遍历，存储
		right++;

		if (p) // 如果该字符已存在，就跳到前面重复字符的下一个位置
		{
			left = p - tmp + 1;     //p指针后一位
		}

		int curlength = right - left; // 当前子串长度
		if (maxlength < curlength)// 找最长
		{
			maxlength = curlength;
		}
	}

	free(tmp);
	return maxlength;
}

int main()
{
    char *s = "abcabcdb";

    int k = lengthOfLongestSubstring(s);
    printf("k=%d\n", k);

    return 0;
}

题目2#

209. 长度最小的子数组

image

方法#

题目要求找一段连续子数组，并且该子数组的和sum要>=target，那么我们首先就是要遍历数组求和，直到sum>=target。

下面我们直接使用滑动窗口的思想进行破题： 那么我们在这里会遇到哪些特殊情况呢？

  • 特例1：整个数组的和都小于target，不过当窗口的右边界越界的时候我们已经跳出循环了，所以也就不需要再做特殊处理；

  • 特例2：有一个数组元素特别大，我们减去前面的一个元素后，sum依然大于target，这时我们就需要先将sum的值不断减小之后才能继续扩大右边界。

程序：C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int minSubArrayLen(int target, int *nums, int numsSize)
{
    int minlen = numsSize + 1; // 最短长度
    int sum = 0;               // 求和
    int left = 0;              // 记录左边界
    int right = 0;
    while (right < numsSize) // 右边界改变
    {
        sum += nums[right++]; // 这里需要更新right，否则结果会少一
        while (sum >= target) // 特例1
        {
            minlen = minlen > right - left ? right - left : minlen;
            sum -= nums[left++]; // 左下标需要右移
        }
    }

    return minlen == numsSize + 1 ? 0 : minlen; // 特例2
}

int main()
{
    int target = 7, nums[] = {2, 3, 1, 2, 4, 3};
    int k = minSubArrayLen(target, nums, sizeof(nums) / sizeof(nums[0]));
    printf("k=%d\n", k);

    return 0;
}

作者：Hang Shao

出处：https://www.cnblogs.com/pam-sh/p/17285796.html

版权：本作品采用「知识共享」许可协议进行许可。

声明：欢迎交流！ 原文链接 ，如有问题,可邮件（mir_soh@163.com）咨询.

posted @   PamShao  阅读(1069)  评论(0)  编辑  收藏  举报
相关博文：
· 面试日记｜小米汽车
· c++：-1
· 窗口滑动算法
· 滑动窗口 Sliding window
· 滑动窗口法——Leetcode例题
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· .NET10 - 预览版1新功能体验（一）
历史上的今天：
2022-04-04 密码算法汇总
2022-04-04 博客园主题记录
2021-04-04 BMP文件格式
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛
more_horiz
keyboard_arrow_up dark_mode palette
选择主题
menu