滑动窗口算法常与双指针等方法结合使用，常用于解决数组、字符串的子元素问题。
维护头尾两个指针，头尾指针之间的部分就是窗口，当满足一定条件时，移动头/尾指针就可以扩大或缩小窗口。
常用方法是初始化头尾指针指向起始位置，尾指针r遍历数组扩大窗口。当满足条件时，移动头指针缩小窗口。

TCP协议中的流量控制，就是使用的滑动窗口算法。

示例1：LeetCode 76.最小覆盖子串

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字母的最小子串。
例如
输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"

这道题就是标准的滑动窗口问题，使用头指针l指向子串的起始位置，尾指针r指向末尾。
向右不断移动尾指针r，扩大窗口。
当l到r组成的子串包含了T中所有字符后，取该子串作为临时结果。
若头指针指向的l字符s[l]，在子串s[l-r]中出现的次数大于在t中出现的次数，将l右移缩小窗口。
如果当前结果小于旧子串，则进行更新。

具体实现如下：

class Solution {
public:
    string minWindow(string s, string t) {
        int n = s.length();
        int size = 0;
       //使用128位数组作为哈希表
        vector<int> m(128, 0);
        string res;
        for(int i=0;i<t.size();i++)
        {
            if(m[int(t[i])] == 0)
            {
                size++;
            }
            m[int(t[i])]++;
        }
        int l = 0, r = 0, count = 0;
        while(r < n)
        {
            //当m[int(s[r])] == 0，则证明子串中s[r]出现次数==t中s[r]出现次数
            if(m[int(s[r])] == 1)
            {
                count++;
            }
            m[int(s[r])]--;
            //如果m[s[l]] < 0，则证明子串中s[r]出现次数>t中s[r]出现次数,l右移不会使子串不满足条件。
            while(m[s[l]] < 0)
            {
                m[int(s[l++])]++;
            }
            //获取子串
            if(count == size && (res.empty() || res.length() > r - l + 1))
            {
                res = s.substr(l, r - l + 1);
            }
            r++;
        }
        return res;
    }
};

示例2：LeetCode 3.无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
例如：
输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

本题同样可以使用滑动窗口算法来解决，窗口内的子串即是无重复字符的子串。
令头指针l指向起始位置，向右移动尾指针r。
当遇到重复字符s[r]时，保存上一段无重复字符的长度。同时，更新l为上一个s[r]的后一个位置，缩小窗口继续遍历。

具体实现如下：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> cm;
        int length = s. length();
        int res = 0;
        int i=0,j=0;
        for(;i<length&&j<length;j++)
        {
            /*两种写法均可
            if(cm.find(s[j]) != cm.end())
            {
                res = max(res, j - i);
                i = max(i,cm[s[j]] + 1);
            }
            cm[s[j]] = j;*/
            if(cm.find(s[j]) != cm.end())
            {
                i = max(i,cm[s[j]] + 1);
            }
            res = max(res, j - i + 1);
            cm[s[j]] = j;
        }
        //res = max(res,length - i);
        return res;
    }
};