将数组中的所有元素添加到哈希表中，然后遍历哈希表，看以当前数为起点或者以当前数为终点的连续序列的长度， 核心优化点： 假如是以当前遍历的数为起点的，判断哈希集合中是否有以他为起点的连续序列， 那么就可以在遍历时，查找哈希集合中是否有 n-1 这样的数，如果有的话，n n为起点的就不是最长的，就可以不进行后面的查找操作了，首先的操作是找到起点或者终点， 这样可以节省很多时间。 —
使用到的几个方法
//哈希集合
boolean add(E e) // 添加元素（若已存在返回 false）
boolean contains(Object o) // 是否包含元素
//遍历
HashSet<String> set = new HashSet<>();
for (String s : set){} //增强 for 循环
Iterator<String> it = set.iterator();//使用 Iterator（可在遍历中删除元素）
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
set.forEach(System.out::println);//使用 Stream（更简洁，但不可改元素和结构）
给定一个整数数组 nums 和一个目标值 target，找出数组中两个数，使它们的和等于 target，并返回它们的下标。
一开始最自然的想法是双重循环，枚举所有两数组合，看是否等于 target。
时间复杂度 O(n^2)，数据量大时会超时。
优化思路：
在遍历数组时，记录已经遍历过的数字。
对于当前数字 x，只需要看 target - x 是否已经出现过。
因此可以使用 HashMap：
遍历一次数组即可解决。
第一想法： 双重 for 循环暴力枚举。
为什么不行： 时间复杂度 O(n^2)，不满足优化要求。
最终解法： 使用 HashMap，在一次遍历中完成查找。
容易出错点：
本质是：
把 O(n) 的查找嵌入到一次遍历中，避免双重循环。
看到“找两个数之和等于 target” + “只需返回一组解”， 立刻想到用 HashMap 记录已遍历元素，用空间换时间。
]]>字母异位词就是一个字符串的字符的不同排列方式，可以使用哈希表，遍历这个字符串，将其中的字符进行排序， 排序后的字符串作为键，为什么不使用字符数组作为键，字符数组作为键的话是它的地址，每一个遍历到的字符串排序后新建的字符数组地址都不一样。 然后符合字母异位词的要求的列表作为值。
（这题的抽象本质是什么？）
例：
总结一下这里使用到的一些方法:
map.put(key, value); // 插入/更新
map.get(key); // 获取value
map.containsKey(key); // 是否包含key
map.remove(key); // 删除对应key的键值对
map.getOrDefault(key, 0); // 不存在时返回默认值
map.values(); // 获取全部的值 返回的正是 Collection 类型
//然后 ArrayList 提供了接收 Collection 的构造方法
new ArrayList<>(map.values()) //可以这样
map.getOrDefault(key, defaultValue) //如果 key 存在，就返回对应的 value；如果 key 不存在，就返回你给的默认值。
//key,要查找的键 如果不存在，则执行第二个参数：lambda表达式函数创建值,然后返回 key 对应的值（现有的或新创建的）
map.computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
s.toCharArray() // 字符串转化为字符数组
Arrays.sort(arr) //对数组进行排序
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
这道题是典型的滑动窗口问题，我们可以用两个指针 left 和 right 来维护一个窗口，这个窗口内的子串就是我们正在检查的子串。
right 扩张: 不断向右移动 right 指针，以扩大窗口，将新的字符纳入窗口中。s[right] 进入窗口时，我们需要判断这个字符是否已经在窗口中存在。
s[right] 不在窗口中，那么我们成功地将窗口扩大了一格，当前窗口的长度就是 right - left + 1，我们更新最大长度。s[right] 已经在窗口中了，说明从 left 到 right 的这个子串包含了重复字符。此时，我们需要收缩窗口。left 收缩: 不断向右移动 left 指针，将 s[left] 移出窗口，直到窗口内不再包含重复的 s[right] 字符。然后 right 指针可以继续扩张。通过这个过程，我们就能遍历所有可能的无重复字符的子串，并找到其中最长的一个。
这是最直观的实现。我们可以用一个 HashSet 来存储当前窗口内的所有字符。
right 指针移动时，检查 s[right] 是否在 HashSet 中。
HashSet，然后 right 指针加一，并更新最大长度 ans = max(ans, set.size())。HashSet 中移除 s[left]，然后 left 指针加一。这个过程一直持续到 s[right] 可以被安全地加入 HashSet 为止。public int lengthOfLongestSubstring(String s) {
char[] arr = s.toCharArray();
int n = arr.length;
HashSet<Character> set = new HashSet<>();
int ans = 0;
int left = 0;
int right = 0;
while(right < n){
if(!set.contains(arr[right])){
set.add(arr[right]);
right++;
// 每次扩大窗口都可能是最长的一次
ans = Math.max(ans, set.size());
}
else{
// 发现重复，收缩窗口
set.remove(arr[left]);
left++;
}
}
return ans;
}
考虑到题目提示 “s 由英文字母、数字、符号和空格组成”，这些都属于 ASCII 字符集。ASCII 码的范围是 0-127。因此，我们可以用一个大小为 128 的布尔数组 has[] 来代替 HashSet，以提高效率。数组的索引就是字符的 ASCII 码。
has[char] 为 true 表示该字符在当前窗口中。has[char] 为 false 表示该字符不在当前窗口中。这种方法的逻辑和 HashSet 完全一样，但数组操作通常比 HashSet 的哈希计算和冲突处理要快。
public int lengthOfLongestSubstringByArray(String s) {
char[] arr = s.toCharArray();
int n = arr.length;
boolean[] has = new boolean[128]; // ASCII 字符集
int ans = 0;
int left = 0;
for(int right = 0; right < n; right++){
// 当发现 arr[right] 已经在窗口中时，收缩窗口
while(has[arr[right]]){
has[arr[left]] = false; // 将左边界字符移出窗口
left++;
}
// 此时 arr[right] 可以安全地加入窗口
has[arr[right]] = true;
// 更新最大长度
ans = Math.max(ans, right - left + 1);
}
return ans;
}
代码 _3_lengthOfLongestSubstring.java 中的 lengthOfLongestSubstringByArrayPlus 方法与此逻辑相同。
HashSet 或 HashMap。给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，并返回这些子串的起始索引。
异位词 是指由相同字母、相同数量组成的字符串，但顺序可能不同。例如, “abc” 和 “cba” 是异位词。
这是最直接但效率最低的方法，对应 findAnagramsBF 函数。
s 的每个字符开始，检查其后长度为 p.length() 的子串。p 都转换成字符数组。s 的长度为 m，p 的长度为 n。
O((m-n) * n log n)。因为外层循环 m-n 次，内部每次都要进行长度为 n 的字符串排序。O(n)，用于存储子串的字符数组。这个方法在 s 很大时会非常慢，通常会导致超时。
这是解决此类问题的标准、高效方法，对应 findAnagramsBySwV2 函数。
核心思想是维护一个固定大小的窗口（大小为 p 的长度），在 s 上滑动。我们不去比较子串本身，而是比较窗口内子串的 字符频率 是否与 p 的字符频率相同。
统计 p 的频率: 使用一个大小为 26 的数组 cnt（因为题目说明是小写英文字母），统计 p 中每个字符出现的次数。
s 中建立一个初始窗口，大小与 p 相同（从索引 0 到 p.length() - 1）。cntTemp 统计这个初始窗口内各字符的频率。cnt 和 cntTemp 两个频率数组是否完全相同。如果相同，则表示当前窗口是一个异位词子串，将窗口的起始索引 left 加入结果列表。left 指针向右移动，所以 s[left] 字符离开窗口。在 cntTemp 中将该字符的计数减一。right 指针向右移动，所以 s[right] 字符进入窗口。在 cntTemp 中将该字符的计数加一。right 指针到达 s 的末尾。findAnagramsBySwV2)public List<Integer> findAnagramsBySwV2(String s, String p) {
List<Integer> ans = new ArrayList<>();
if (s.length() < p.length()) return ans;
int n = p.length();
int[] cnt = new int[26]; // p 的字符频率
int[] cntTemp = new int[26]; // 窗口的字符频率
// 1. 统计 p 的频率，并初始化第一个窗口的频率
for (int i = 0; i < n; i++) {
cnt[p.charAt(i) - 'a']++;
cntTemp[s.charAt(i) - 'a']++;
}
// 2. 检查第一个窗口
if (Arrays.equals(cnt, cntTemp)) {
ans.add(0);
}
// 3. 开始滑动窗口
for (int left = 1; left <= s.length() - n; left++) {
int right = left + n - 1;
// 移出 s[left-1]
cntTemp[s.charAt(left - 1) - 'a']--;
// 移入 s[right]
cntTemp[s.charAt(right) - 'a']++;
// 再次比较
if (Arrays.equals(cnt, cntTemp)) {
ans.add(left);
}
}
return ans;
}
注：你提供的 findAnagramsBySwV2 在循环的实现上略有不同，但核心思想是一致的。以上版本是另一种常见的、等效的滑动窗口实现。
O(m)。我们只需要遍历一遍字符串 s。数组比较是 O(1)（因为数组大小固定为 26）。O(1)，因为我们只用了两个固定大小的数组。滑动窗口通过复用前一步的计算结果（只更新离开和进入窗口的两个字符），避免了暴力法中大量的重复排序和比较工作，是解决子串/子数组问题的强大技巧。
]]>给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的连续子数组的个数 。
k，加上一个负数后仍可能等于 k。因此，不能简单地用滑动窗口来优化。O(n^2) 超时：最直观的暴力解法是枚举所有子数组的起点和终点，计算其和，时间复杂度为 O(n^3) 或优化后的 O(n^2)，在数据量较大时会超时。
第一想法：
通过两层循环枚举所有连续子数组。外层循环固定子数组的右端点 i，内层循环枚举左端点 j，计算 [j, i] 区间的和。
为什么不行：
时间复杂度为 O(n^2)，当 nums 数组的长度很大时，会导致性能问题，无法通过所有测试用例。
pre[i] 为 nums[0..i-1] 的元素和。那么，任意连续子数组 nums[j..i] 的和就可以表示为 pre[i+1] - pre[j]。pre[i+1] - pre[j] == k。pre[j] = pre[i+1] - k。i，我们只需要找到在它之前，有多少个位置 j 的前缀和 pre[j] 恰好等于 pre[i+1] - k。key 是前缀和的值，value 是该前-缀和值已经出现过的次数。current_sum。在哈希表中查找 current_sum - k 是否存在。如果存在，说明找到了若干个满足条件的子数组，将对应的 value 累加到最终结果 ans 中。current_sum 存入哈希表（或更新其出现次数），供后续的计算使用。pre[j] 中 j=0 的情况，其前缀和为 0），需要在哈希表中预先放入 (0, 1)，表示和为 0 的前缀和已经出现过 1 次。本题的本质是将 “求解定值子数组和” 的问题，通过 “前缀和” 技巧，转化为一个 “寻找两个前缀和之差为定值” 的问题。这与 “两数之和” 问题的思想非常相似，因此可以利用 哈希表 来高效地进行查找，将时间复杂度从 O(n^2) 优化到 O(n)。
（一句话总结触发器）
看到 “连续子数组和”、“定值 k” 且包含负数 → 前缀和 + 哈希表。
给定一个非负整数数组 height ，每个数代表一个点的坐标 (i, height[i])。在坐标系中画 n 条垂直线，第 i 条线的两个端点分别为 (i, 0) 和 (i, height[i])。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
这道题的经典解法是双指针法。我们使用两个指针，一个指向数组的开头（left），另一个指向数组的末尾（right）。这两个指针代表了容器的两条边。
容器的面积取决于两个因素：
right - left。min(height[left], height[right])。因此，面积 Area = min(height[left], height[right]) * (right - left)。
我们的目标是让这个面积最大化。
left = 0，右指针 right = height.length - 1。maxArea = 0。left < right 时，循环执行以下步骤：
a. 计算当前指针构成的容器面积：currentArea = min(height[left], height[right]) * (right - left)。
b. 更新最大面积：maxArea = max(maxArea, currentArea)。
c. 移动指针：比较 height[left] 和 height[right] 的高度。为了找到可能更大的面积，我们选择移动指向较短边的那一侧指针。
height[left] <= height[right]，则 left++。right--。maxArea 即为所求答案。这是一个贪心策略。我们来证明为什么每次移动较短的边，不会错过最优解。
假设我们当前的左右指针为 left 和 right，并且 height[left] < height[right]。
此时的面积是 Area = height[left] * (right - left)。
我们有两个选择：
移动右指针 right：right--。新的宽度变成了 right - 1 - left，比原来小。新的高度是 min(height[left], height[right-1])。因为 height[left] 已经是较短的边，所以新的高度最大也只能是 height[left]。宽度变小了，高度没有增加，所以新的面积 Area_new = min(height[left], height[right-1]) * (right - 1 - left) <= height[left] * (right - 1 - left) < Area。因此，移动较高的边（right）不可能得到更大的面积。
移动左指针 left：left++。新的宽度 right - (left + 1) 也变小了。但新的高度 min(height[left+1], height[right]) 可能会变大。如果 height[left+1] 足够大，就有可能弥补宽度减小的损失，从而得到一个更大的面积。
因此，在每一步中，我们固定较高的那条边，移动较低的那条边，才有可能找到一个更大的容器面积。这个策略保证了我们朝着面积可能增大的方向探索，最终能够找到全局最优解。
双指针法是解决此问题的关键。通过从两端向中间收缩，并始终移动较短的板，我们可以在 O(n) 的时间复杂度内有效地找到最大面积。这个方法之所以有效，是因为容器的面积由短板和宽度共同决定，移动短板是唯一可能找到更大面积的策略。
]]>在一个数组中找出所有和为 0 且不重复的三元组。
解决这类问题的通常思路是从暴力解法开始，逐步优化，最终得到高效的解法。
最直观的想法是穷举所有可能。用三层循环遍历数组，找出所有三个数的组合，判断它们的和是否为 0。
for i from 0 to n-1:
for j from i+1 to n-1:
for k from j+1 to n-1:
if nums[i] + nums[j] + nums[k] == 0:
add (nums[i], nums[j], nums[k]) to result
HashSet）对结果进行去重，增加了复杂性。为了降低复杂度，我们可以尝试减少一层循环。思路是“固定一个数，找另外两个数”。
我们遍历数组，固定第一个数 nums[i]，那么问题就转化为：在数组的剩余部分中寻找两个数，使它们的和等于 -nums[i]。这就把“3Sum”问题降维成了我们熟悉的“2Sum”问题。
如何解决这个内部的“2Sum”问题？
nums[i] 之后的部分，对于每个 nums[j]，我们去哈希表中查找是否存在 target - nums[j]（其中 target = -nums[i]）。这方法可行，整体时间复杂度为 O(n²)，空间复杂度为 O(n)。（这对应了 threeSumBF 方法的思路）。结合“降维”和“有序数组”这两个思想，最终的解法浮出水面。
排序 (Sort): 首先对整个数组进行排序，时间复杂度 O(n log n)。排序是使用双指针的前提，并且极大地简化了去重操作。
遍历与固定 (Outer Loop): 遍历排序后的数组，用 for 循环固定第一个数 nums[i]。
nums[i] 后面的区间 [i+1, n-1] 上，设置左指针 left = i + 1 和右指针 right = n - 1。
sum = nums[i] + nums[left] + nums[right]。sum == 0，说明找到了一个解。记录下来，然后同时移动 left 和 right 指针并跳过所有重复元素，继续寻找其他解。sum < 0，说明和太小了，需要增大。因为数组是有序的，所以移动左指针 left++。sum > 0，说明和太大了，需要减小。移动右指针 right--。nums[i] 时，如果 i > 0 且 nums[i] 和它前一个数 nums[i-1] 相等，说明以 nums[i] 开头能找到的三元组，之前以 nums[i-1] 开头时肯定都已经找到了。因此可以直接跳过，避免重复计算。sum == 0 找到一个解后，需要将 left 和 right 指针移动到下一个不重复的位置，以防同一个三元组被多次记录。这个“排序 + 双指针”的方案，将时间复杂度降到了 O(n²)，空间复杂度为 O(1)（不考虑结果存储空间），是此问题的最佳解法。
这个“排序 + N指针”的思路可以推广到更一般性的“K-Sum”问题。
for + two_pointers。for + 3Sum_logic，即 for + for + two_pointers。 function kSum(nums, target, k):
// 提前剪枝
if a few base cases fail, return []
if k == 2:
return twoSum(nums, target) // 双指针解决
for i from 0 to n-1:
// 去重
if i > 0 and nums[i] == nums[i-1]:
continue
// 递归调用 (k-1)Sum
sub_results = (k-1)Sum(nums[i+1:], target - nums[i], k-1)
// 组合结果
for res in sub_results:
result.add([nums[i]] + res)
return result
我的最初的思路是：对于这个数组：使用双指针，一个指针p1指向0，一个指针p2指向第一个非0，然后找到了之后，将p2的值覆盖p1的值。然后两个同时后移。 终止条件是p2到达数组的末尾，此时将后面的非0数移动到前面了，然后就是要将后面的数变为0，要从p1开始后面的。
思路二：将数组看作栈，一个指针维护栈顶，一个指针维护当前变量，是0跳过，非0压入栈中，然后为了节省空间，可以直接使用原来的数组做栈。 之后将非0的数放入前面之后，将后面的几个变为0.
第一个思路和第二个思路都有一个不足，当数组全是0的话，都需要多次遍历，一次查找，一次变0.
思路三：上面思路的不足是因为非0数前移是覆盖，这个思路采用的是交换，保证两个数组之间维护着一组0，最终当右指针到了数组末尾的话，0就也到了末尾了。
给定一个非负整数数组 height ，每个整数代表一个柱子的高度，柱子的宽度为 1。计算下雨后，这些柱子能接多少雨水。
这道题是求解一个二维图形中可以容纳多少“水”，核心在于确定每个位置上方能蓄水的高度。
最直观的想法是，对于数组中的每一个位置 i，它能接的雨水数量取决于其左侧最高柱子和右侧最高柱子中最矮的那个。具体来说，i 位置的水位高度是 min(左侧最高柱子高度, 右侧最高柱子高度)。那么，i 位置能接的雨水量就是 水位高度 - height[i]。
但是，每次都去遍历查找左右两侧的最高柱子，时间复杂度会达到 O(n^2)，效率不高。
我们可以优化这个过程。通过两次遍历，预先计算出每个位置的左侧最高和右侧最高。
preMax，其中 preMax[i] 记录从 0 到 i 的最高柱子高度。sufMax，其中 sufMax[i] 记录从 i 到 n-1 的最高柱子高度。i，其能接的雨水量就是 min(preMax[i], sufMax[i]) - height[i]。这个方法将时间复杂度降到了 O(n)，但需要 O(n) 的额外空间。这对应了代码中的 trapByArray 方法。
在思路一的基础上，我们思考是否可以优化空间复杂度，去掉额外的 preMax 和 sufMax 数组。
我们可以使用两个指针，left 从数组开头，right 从数组末尾，相向移动。同时维护两个变量，preMax 表示 [0...left] 区间的最高柱子，sufMax 表示 [right...n-1] 区间的最高柱子。
在 left 和 right 指针相遇之前，循环执行以下逻辑：
preMax 和 sufMax。preMax < sufMax：
left 指针所在的位置，它的左侧最高墙（preMax）比右侧已经看到的最高墙（sufMax）要矮。由于 sufMax 只是 [right...n-1] 的最大值，整个数组 [left...n-1] 的真实最大值肯定不小于 sufMax。因此，left 位置的水位就由 preMax 决定了。left 位置的雨水量：preMax - height[left]，累加到总结果中。left 指针右移，并更新 preMax。preMax >= sufMax：
right 指针所在的位置，它的右侧最高墙（sufMax）是瓶颈。right 位置的水位由 sufMax 决定。right 位置的雨水量：sufMax - height[right]，累加到总结果中。right 指针左移，并更新 sufMax。这个方法非常巧妙，它在一次遍历中完成了计算，时间复杂度为 O(n)，空间复杂度为 O(1)。这对应了代码中的 trapByTwoPointers 方法。
这道题也可以用单调栈来解决。栈里存放的是柱子的索引。我们维护一个单调递减栈。
height[i] 小于等于栈顶柱子高度时，将 i 入栈。height[i] 大于栈顶柱子高度时，说明出现了一个“凹”槽，可以蓄水。此时，栈顶元素 top 就是凹槽的底部。top 出栈后，新的栈顶元素 left = st.peek() 就是凹槽的左边界，而当前柱子 i 就是右边界。i - left - 1，高度是 min(height[left], height[i]) - height[top]。单调栈提供了一个不同的视角，对于求解“最近的最大/最小值”这类问题非常有效。
这道题的几种解法都非常经典，体现了算法优化的常见思路。
通过本题，可以深刻理解以上几种数据结构和算法思想的巧妙之处，并学会在不同场景下选择合适的方案来优化时间和空间复杂度。
]]>