找到字符串中所有字母异位词（暴力搜索、滑动窗口、优化的滑动窗口三种解法）

一、题目 

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

 示例 2:

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。

提示:

1 <= s.length, p.length <= 3 * 104
s 和 p 仅包含小写字母

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-all-anagrams-in-a-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、暴力搜索

        这个非常好理解，我创建一个方法来帮助判断两个字符串的字母数量是否相等，若相等那不管什么排序都是异位词，然后利用substring不断遍历即可，但这种做法的效率极其低下，不推荐使用。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> list = new ArrayList<>();
        int len = p.length();
        for(int i = 0; i < (s.length() - len + 1); i++) {
            if(helper(s.substring(i, i + len), p)) {
                list.add(i);
            }
        }
        return list;
    }

    public boolean helper(String s, String p) {
        int[] count = new int[26];
        for(int i = 0; i < s.length(); i++) {
            count[s.charAt(i) - 'a']++;
        }
        for(int i = 0; i < p.length(); i++) {
            if(--count[p.charAt(i) - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
}

三、滑动窗口

        顾名思义，看起来就很像一个窗口不断滑动遍历，怎么实现呢？

        利用左右指针即可，这个解法大家读代码其实就能理解了，我做了注释。其实就是维护一个长度为p.length()+1的窗口，将s填充进去，然后比较是否相等。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        int sLen = s.length();
        int pLen = p.length();
        if(sLen < pLen) {//小于肯定就不存在异位词了
            return new ArrayList<Integer>();
        }
        
        List<Integer> list = new ArrayList<>();
        int[] sCount = new int[26];
        int[] pCount = new int[26];

        for(int i = 0; i < pLen; i++) {//先初始化
            sCount[s.charAt(i) - 'a']++;
            pCount[p.charAt(i) - 'a']++;
        }
        if(Arrays.equals(sCount, pCount)) {
            list.add(0);
        }

        for(int i = 0; i < sLen - pLen; i++) {//开始维护长度为pLen + 1的滑动窗口
            --sCount[s.charAt(i) - 'a'];//已经统计过，需要减去
            ++sCount[s.charAt(i + pLen) - 'a'];//加进新的元素
            if(Arrays.equals(sCount, pCount)) {
                list.add(i + 1);//别忘了加1，因为实际比较的是i+1开始的部分
            }
        }

        return list;
    }
}

四、优化的滑动窗口

        一定要先理解滑动窗口是什么再来看这个解法，不然理解起来较为困难。

        它将上一种解法的两个计数数组缩减为了一个，并引入了differ来统计两个字符串不同的数量，当differ=0时表明是异位词。我觉得最大难点是最后遍历s时differ的加减问题。因为只有一个数组计数，相当于只能根据初始化时留下来的数据来判断后续的字符串是不是异位词。需要大家思考一下，但其实是相互对应的，理解了这一层就能思考清楚了。

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        int sLen = s.length();
        int pLen = p.length();
        if(sLen < pLen) {//小于肯定就不存在异位词了
            return new ArrayList<Integer>();
        }
        
        List<Integer> list = new ArrayList<>();
        int[] count = new int[26];
        int differ = 0;//用来记录不同的个数

        for(int i = 0; i < pLen; i++) {//初始化
            count[s.charAt(i) - 'a']++;
            count[p.charAt(i) - 'a']--;
        }
        for(int a : count) {
            if(a != 0) {
                differ++;
            }
        }
        if(differ == 0) {//没有不同
            list.add(0);
        }

        for(int i = 0; i < sLen - pLen; i++) {
            //记住charAt(i)的数是已经统计过，需要抹去的
            if(count[s.charAt(i) - 'a'] == 1) {
                differ--;
            }
            if(count[s.charAt(i) - 'a'] == 0) {//与后面的-1对应
                differ++;
            }
            count[s.charAt(i) - 'a']--;

            if(count[s.charAt(i + pLen) - 'a'] == -1) {
                differ--;
            }
            if(count[s.charAt(i + pLen) - 'a'] == 0) {
                differ++;
            }
            count[s.charAt(i + pLen) - 'a']++;

            if(differ == 0) {
                list.add(i + 1);
            }
        }
        
        return list;
    }
}

五、三种方法的比较

这是不同方法所消耗的时间与空间