LeetCodeHot100(滑动窗口和子串篇)

---

---

滑动窗口&子串

无重复字符的最长子串

题目

给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。

代码

class Solution {
    public int lengthOfLongestSubstring(String s) {
        // 定义一个数组存储每个字符 上次 出现的位置(相当于哈希表)
        // s 由英文字母、数字、符号和空格组成 java的ascii码表一共是128个
        // 所以设置字符长度大小为128
        int[] temp=new int[128];
        for(int i=0;i<temp.length;i++){
            temp[i]=-1;//因为每个字符第一次出现的话 跟0比较 所以预处理为-1
        }
        int ans=0;//定义一个结果变量
        //遍历整个字符串 begin初始索引 i向后遍历的索引 下面的方法可以遍历到所有不含有重复字符的子串
        for(int i=0,begin=0;i<s.length();i++){
            //遍历的同时 维护窗口的左右边界
            //如果当前字符重复的话  直接将begin变成重复字符(之前)的下一个位置
            begin=Math.max(begin,temp[s.charAt(i)]+1);
            ans=Math.max(ans,i-begin+1);
            temp[s.charAt(i)]=i;//存储当前字符的位置
        }
        return ans;
    }
}

找到字符串中所有字母异位词

题目

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

代码

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        // 找到s中所有p的异位词的子串，返回这些子串的起始索引。
        int slen = s.length();
        int plen = p.length();
        Map<Character, Integer> mp = new HashMap<>();
        List<Integer> res = new LinkedList<>(); // 存储索引结果
        int begin = 0;
        if(slen<plen) return res;
        // 将p中出现的字符个数统计出来
        for (char ch : p.toCharArray()) {
            mp.put(ch, mp.getOrDefault(ch, 0) + 1);
        }
        // 遍历主串的过程中将mp哈希映射中的值进行减少，并判断值是否小于0
        // 如果小于0，证明当前字符不是p中有的字符，则将begin指针进行移动
        for (int i = 0; i < slen; i++) {
            char curChar = s.charAt(i);
            mp.put(curChar, mp.getOrDefault(curChar, 0) - 1);
            // 当前字符数量小于0，说明出现了多余的字符，调整窗口左边界
            while (mp.get(curChar) < 0) {
                mp.put(s.charAt(begin), mp.get(s.charAt(begin)) + 1);//恢复原先窗口的与p中相同字符数量 如果不恢复的话，滑动窗口左边界会一直右移
                begin++;
            }
            // 窗口大小等于模式串长度时记录开始位置
            if (i - begin + 1 == plen) {
                res.add(begin);
            }
        }
        return res;
    }
}

和为 K 的子数组

题目

给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。
子数组是数组中元素的连续非空序列。

代码

class Solution {
    public int subarraySum(int[] nums, int k) {
        //给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。
        //子数组是数组中元素的连续非空序列
        int count = 0;
        int[] sum = new int[nums.length]; // 前缀和数组
        Map<Integer, Integer> mp = new HashMap<>(); // 哈希表统计每个数字出现的次数

        // 求前缀和数组
        sum[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            sum[i] = sum[i - 1] + nums[i];
        }
        // 添加前缀和为 0 的情况，这是为了处理以第一个元素开头的子数组
        mp.put(0, 1);
        // 遍历前缀和数组 [j..i] 这个子数组和为 k  这个条件我们可以转化为
        // sum[i]−sum[j−1]==k
        // 简单移项可得符合条件的下标 j 需要满足
        // sum[j−1]==sum[i]−k
        for (int i = 0; i < sum.length; i++) {
            // 检查是否存在 sum[i] - k
            if (mp.containsKey(sum[i] - k)) {
                count += mp.get(sum[i] - k);
            }
            mp.put(sum[i], mp.getOrDefault(sum[i], 0) + 1);
        }
        return count;
    }
}

滑动窗口最大值

题目

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回 滑动窗口中的最大值 。

代码

//自定义数组
class MyQueue {
    Deque<Integer> deque = new LinkedList<>();
    //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
    //同时判断队列当前是否为空
    void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            deque.poll();
        }
    }
    //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
    //保证队列元素单调递减
    //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
    void add(int val) {
        while (!deque.isEmpty() && val > deque.getLast()) {//将队列中比当前要加入队列数小的数全部弹出
            deque.removeLast();
        }
        deque.add(val);
    }
    //队列队顶元素始终为最大值
    int peek() {
        return deque.peek();
    }
}

class Solution {
    //自定义单调队列解法 把最大值维护在队列的出口处
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1) {
            return nums;
        }
        int len = nums.length - k + 1;//8-3+1=6
        //存放结果元素的数组
        int[] res = new int[len];
        int num = 0;
        //自定义队列
        MyQueue myQueue = new MyQueue();
        //先将前k的元素放入队列
        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }
        res[num++] = myQueue.peek();
        for (int i = k; i < nums.length; i++) {
            //滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
            myQueue.poll(nums[i - k]);
            //滑动窗口加入最后面的元素
            myQueue.add(nums[i]);
            //记录对应的最大值
            res[num++] = myQueue.peek();
        }
        return res;
    }
}

最小覆盖子串

题目

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。

代码

class Solution {
public:
    string minWindow(string s, string t) {
        //哈希映射  
        // 返回符合条件的最短子串即可（滑动窗口）
        //找不到直接 return  ""
        unordered_map<char,int> hs,ht;
        //统计t中每个字符的数量
        for(int i=0;i<t.size();i++){
            ht[t[i]]++;
        }
        string ans="";
        //滑动窗口的左右边界 当前窗口有效字符的数量cnt
        for(int i=0,begin=0,cnt=0;i<s.size();i++){
            //当前字符数量小于等于 t规定字符数量 为合法字符 继续移动
            if(++hs[s[i]]<=ht[s[i]]){
                cnt++;
            }
            //去除窗口中的冗余字符
            while(hs[s[begin]]>ht[s[begin]]){
                hs[s[begin]]--;//减少冗余的字符数
                begin++;
            }
            //当有效字符数等于字符t的大小时  说明是有效字符串
            if(cnt==t.size()){
                //当前结果为空或者结果长度大于窗口长度 则将结果长度更新为更小的长度
                if(ans.empty()||ans.size()>i-begin+1){
                    //substr 从begin位置开始 取i-begin+1个长度的串
                    ans=s.substr(begin,i-begin+1);
                }
            }
        }
        return ans;
    }
};

后续内容持续更新~~~