前端实践选题文章：滑动窗口算法解析与实现
背景
在算法的学习和前端开发实践中，滑动窗口是一种非常高效的算法技巧，尤其适用于字符串或数组相关的问题。滑动窗口算法通过动态调整窗口的边界，不断优化结果，避免了暴力求解的高时间复杂度。
题目描述
题目：最小替换子串长度
小U得到了一个只包含 A、S、D、F 的字符串，字符串长度总是 4 的倍数。她希望通过尽可能少的替换，使得 A、S、D 和 F 四个字符在字符串中出现的频次相等。请计算满足该条件的最短替换子串的长度。
输入输出示例：
- 输入：
input = "ADDF"
输出：1 - 输入：
input = "ASAFASAFADDD"
输出：3 - 输入：
input = "SSDFFFASADDDFFF"
输出：1
思路解析
这道题的核心是找到一个子串，通过替换子串中的字符，使得剩余部分的字符分布平衡。为了解决问题，我们需要实现以下步骤：
- 计算目标频率：
字符串总长度n是4的倍数，因此每个字符A、S、D、F的理想频率为n / 4。 - 判断当前状态是否平衡：
通过计算每个字符的频率，与目标频率进行比较，判断是否需要替换。 - 滑动窗口求解：
使用滑动窗口算法，动态调整窗口的左右边界，找到满足条件的最短子串。
代码实现与解析
以下是该题的 Java 代码实现。
import java.util.HashMap;
import java.util.Map;
public class Main {
public static int solution(String input) {
int n = input.length(); // 字符串长度
int target = n / 4; // 每个字符的目标频率
Map<Character, Integer> count = new HashMap<>();
// 初始化每个字符的频率
for (char c : input.toCharArray()) {
count.put(c, count.getOrDefault(c, 0) + 1);
}
// 如果字符串已经平衡，无需操作
if (isBalanced(count, target)) return 0;
int left = 0, minLength = n;
// 滑动窗口调整
for (int right = 0; right < n; right++) {
// 减少当前字符的频率
count.put(input.charAt(right), count.get(input.charAt(right)) - 1);
// 当窗口满足条件时，尝试缩小窗口
while (isBalanced(count, target) && left <= right) {
minLength = Math.min(minLength, right - left + 1); // 更新最小长度
count.put(input.charAt(left), count.get(input.charAt(left)) + 1); // 左边界右移
left++;
}
}
return minLength;
}
// 判断当前字符分布是否满足目标
private static boolean isBalanced(Map<Character, Integer> count, int target) {
return count.getOrDefault('A', 0) <= target &&
count.getOrDefault('S', 0) <= target &&
count.getOrDefault('D', 0) <= target &&
count.getOrDefault('F', 0) <= target;
}
public static void main(String[] args) {
System.out.println(solution("ADDF") == 1);
System.out.println(solution("ASAFASAFADDD") == 3);
System.out.println(solution("SSDFFFASADDDFFF") == 1);
System.out.println(solution("AAAASSSSDDDDFFFF") == 0);
System.out.println(solution("AAAAADDAAAASSSSS") == 4);
}
}
代码解析
-
初始化字符频率：
for (char c : input.toCharArray()) { count.put(c, count.getOrDefault(c, 0) + 1); }遍历输入字符串，统计每个字符的出现频率，存入
HashMap中。 -
滑动窗口调整：
for (int right = 0; right < n; right++) { count.put(input.charAt(right), count.get(input.charAt(right)) - 1); while (isBalanced(count, target) && left <= right) { minLength = Math.min(minLength, right - left + 1); count.put(input.charAt(left), count.get(input.charAt(left)) + 1); left++; } }right：滑动窗口的右边界。- 在每次循环中，将窗口右边的字符计数减少，并判断是否满足平衡条件。
- 如果满足，则尝试通过移动左边界来缩小窗口，记录最小子串长度。
-
判断是否平衡：
private static boolean isBalanced(Map<Character, Integer> count, int target) { return count.getOrDefault('A', 0) <= target && count.getOrDefault('S', 0) <= target && count.getOrDefault('D', 0) <= target && count.getOrDefault('F', 0) <= target; }检查当前窗口外的字符频率是否都小于等于目标频率。
实际效果与优化点
通过滑动窗口算法，该代码成功将时间复杂度优化至 O(n)，避免了暴力求解的高开销。针对不同的输入字符串，代码能够高效地计算出最小替换子串的长度。
例如：
- 对于输入
AAAAADDAAAASSSSS，窗口动态调整后找到最优子串长度为 4。 - 对于完全平衡的字符串
AAAASSSSDDDDFFFF，直接返回结果 0。
扩展总结与其他题目分析
1. 滑动窗口的核心思想
滑动窗口的核心在于：
- 动态调整窗口范围：通过左右指针维护窗口区间，并根据条件动态扩大或缩小窗口。
- 优化性能：避免暴力遍历，减少不必要的重复计算。
2. 滑动窗口的典型应用场景
滑动窗口算法适用于处理连续子数组或子字符串问题。以下是几个经典题目及其代码实现。
案例一：找到最长无重复子串
问题描述：
给定一个字符串 s，找到其中最长的无重复字符的子串长度。
代码实现：
public int lengthOfLongestSubstring(String s) {
int n = s.length();
int left = 0, maxLength = 0;
Set<Character> set = new HashSet<>();
for (int right = 0; right < n; right++) {
while (set.contains(s.charAt(right))) {
set.remove(s.charAt(left));
left++;
}
set.add(s.charAt(right));
maxLength = Math.max(maxLength, right - left + 1);
}
return maxLength;
}
解析：
- 窗口扩展：右指针逐步扩展窗口。
- 窗口收缩：当窗口内出现重复字符时，通过移动左指针剔除重复字符。
- 性能优化：相比暴力检查每个子串的重复性，该算法只需 O(n) 时间。
案例二：和为目标值的最短子数组
问题描述：
给定一个正整数数组 nums 和目标值 target，找出和大于等于目标值的最短连续子数组长度。
代码实现：
public int minSubArrayLen(int target, int[] nums) {
int n = nums.length;
int left = 0, sum = 0, minLength = Integer.MAX_VALUE;
for (int right = 0; right < n; right++) {
sum += nums[right];
while (sum >= target) {
minLength = Math.min(minLength, right - left + 1);
sum -= nums[left];
left++;
}
}
return minLength == Integer.MAX_VALUE ? 0 : minLength;
}
解析：
- 窗口扩展：通过右指针逐步扩展窗口，累加窗口内的数字。
- 窗口收缩：当窗口内的和达到目标值时，尝试通过移动左指针来缩小窗口。
- 实践启发：类似问题在前端开发中常用于动态数据流处理，如分页加载、滚动计算等场景。
案例三：包含所有字符的最小子串
问题描述：
给定两个字符串 s 和 t，找到 s 中包含 t 所有字符的最小子串。
代码实现：
public String minWindow(String s, String t) {
Map<Character, Integer> map = new HashMap<>();
for (char c : t.toCharArray()) {
map.put(c, map.getOrDefault(c, 0) + 1);
}
int left = 0, count = 0, minLength = Integer.MAX_VALUE;
int start = 0;
for (int right = 0; right < s.length(); right++) {
char c = s.charAt(right);
if (map.containsKey(c)) {
map.put(c, map.get(c) - 1);
if (map.get(c) >= 0) count++;
}
while (count == t.length()) {
if (right - left + 1 < minLength) {
minLength = right - left + 1;
start = left;
}
char leftChar = s.charAt(left);
if (map.containsKey(leftChar)) {
map.put(leftChar, map.get(leftChar) + 1);
if (map.get(leftChar) > 0) count--;
}
left++;
}
}
return minLength == Integer.MAX_VALUE ? "" : s.substring(start, start + minLength);
}
解析：
- 复杂度控制：通过滑动窗口，动态调整窗口大小，避免遍历所有子串的 O(n^2) 复杂度。
- 实践应用：该算法适用于前端中处理用户输入的模糊匹配或搜索推荐功能。
实践与思考
1. 滑动窗口对比暴力解法
滑动窗口的核心优势在于减少了不必要的重复计算，通过维护动态窗口状态，解决了许多暴力解法的性能瓶颈。
2. 优化细节与工程实践
- 边界条件处理：如空字符串、特殊字符，需在实际开发中针对不同输入做全面覆盖。
- 数据结构选择：合理使用
HashSet、HashMap等集合工具，提升查询效率。 - 灵活性与扩展性：滑动窗口算法可扩展至处理动态数组、实时流数据等场景，在前端工程中具备较强的适用性。
3. 前端实践中的场景
- 动态搜索优化：实现高性能的前端搜索框联想功能，实时匹配用户输入与目标数据。
- 分页加载与滚动计算：针对无限滚动页面，实现高效的动态加载与窗口裁剪。
- 数据流处理：在前端大数据可视化中，动态处理实时输入数据，构建滑动窗口图表展示。
