01 双指针相关知识
在处理数组和链表相关问题时，双指针技巧是经常用到的，双指针技巧主要分为两类：左右指针和快慢指针。
（1）左右指针
定义：两个指针相向而行或者相背而行。左右指针的常用算法包括二分查找、n数之和、反转数组、回文串判断。只要数组有序，就应该想到双指针技巧。左右指针既可以从两端向中间相向而行，也可以是从中心向两端扩展（这种情况主要是处理回文串类问题）。
（2）快慢指针
定义：快慢指针，是两个指针同向而行，一快一慢。快慢指针常用的算法包括原地修改、滑动窗口。原地修改是指不允许新建数组，只能在原数组上操作。
02 LeetCode真题之盛水最多的容器
题目描述：
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。
示例 1：
输入：[1,8,6,2,5,4,8,3,7] 输出：49 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例 2：
输入：height = [1,1] 输出：1
提示：
n == height.length2 <= n <= 1050 <= height[i] <= 104
（1）暴力枚举
思路：首先要题解题意，容器能容纳的水是由两个边界（left, right）中较小的一个height[min]决定的，其实就是面积area=(right - left) * height[min]。最容易想到的就是枚举，使用两层for循环，寻找所有可能的area。第一层for循环的i表示枚举左边界，第二层for循环从i+1开始，表示可能的右边界，循环结束，返回最大的area即可。这段代码放到leetcode上面超时了，放上代码记录自己思考的过程。
Java实现代码
// 结果正确但是会超时
public static int maxArea(int[] height){
// 暴力解法，逐个枚举，两层for循环
int maxArea = 0;
for (int i = 0; i < height.length; i++) {
for(int j = i + 1; j < height.length; j++){
// 面积等于底*高
int area = (j - i) * Math.min(height[i], height[j]);
maxArea = Math.max(area, maxArea);
}
}
return maxArea;
}（2）双指针
思路：首先要理解，双指针代表的是什么？答案是可以作为容器左右边界的所有位置的范围。在一开始，双指针指向数组的左右边界。其次在这个问题里难倒我们的是如何定义指针的移动？（即应该移动数字较大的指针还是数字较小的）初始面积area=(left - right) * min(height[left], height[right])。由于我们的左右指针是相对而行的，（left - right）必然是递减的。此时我们考虑两种情况，如果移动数字较大的指针，那面积的变化肯定是逐步减小的，这与我们要求最大容积的要求相悖；如果移动数字较小的指针，面积的变化可能是变大、不变或变小。因此我们应该移动数字较小的指针。最后将最大值返回即为答案。
Java实现代码
// 双指针解法
public static int maxArea(int[] height){
int n = height.length;
int maxArea = 0;
// 定义左右指针
int left = 0, right = n-1;
// 判断循环结束，由于不需要关注left=right的情况，因此用<
while(left < right) {
// 盛水面积=底*较小的高
int area = (right - left) * Math.min(height[left], height[right]);
maxArea = Math.max(area, maxArea);
// 由于初始底是最长的，面积大小只受较小的高的影响，而底是越来越小的
// 如果较小的高不变，只改变底，面积只会越来越小，同时改变底和高，面积可能不变，变大或变小
// 因此在改变左右指针的位置时（缩小底的长度），应该移动较小的高
if(height[left] < height[right]){
left++;
}else {
right--;
}
}
return maxArea;
}
03 LeetCode真题之三数之和
题目描述：
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。 注意，输出的顺序和三元组的顺序并不重要。
示例 2：
输入：nums = [0,1,1] 输出：[] 解释：唯一可能的三元组和不为 0 。
示例 3：
输入：nums = [0,0,0] 输出：[[0,0,0]] 解释：唯一可能的三元组和为 0 。
提示：
3 <= nums.length <= 3000-105 <= nums[i] <= 105
（1） 排序 + 双指针第一版
思路：最容易想到的就是使用三重循环，暴力解题，但是题目中要求找到所有不重复且和为0，此时就不能单纯的使用三重循环了，还需要引入哈希表进行去重，这样费时费空间。我们分析一下不重复的本质，保持三重循环的大框架不变，只要保证：（1）第二重循环枚举到的元素不小于当前第一重循环枚举到的元素（2）第三重循环枚举到的元素不小于当前第二重循环枚举到的元素。即，枚举的三元组（a，b，c）满足a≤b≤c， 保证了只有（a，b，c）会被枚举到，而（b，a，c）、（c，b，a）等不会被枚举到，这样就减少了重复。可以对数组中的元素进行排序，然后再使用三重循环进行解题。
对于每一重循环而言，要确保相邻两次枚举的元素不能相同，否则也会造成重复。
如果固定了前两重循环枚举的元素a和b，那么只有唯一的c满足三者和为0，当第二重循环往后枚举一个元素b'时，由于b'>b（因为数组已经从小到大排序了），那么满足和为0的c'一定是小于c的，即c'在数组中一定出现在c的左侧。也就是说，从小到大枚举b，同时从大到小枚举c，即第二重循环和第三重循环实际上是并列的关系。这样就可以保持第二重循环不变，将第三重循环变成一个从数组最右端开始向左移动的指针。这就是常说的双指针的思想，当需要枚举数组中的两个元素时，如果我们发现随着第一个元素的递增，第二个元素是递减的，就可以使用双指针的方法，将枚举的时间复杂度从O(N²)减少到O(N)。
Java实现代码
public static List<List<Integer>> threeSum(int[] nums) {
// 先对数组进行排序
Arrays.sort(nums);
// 存储最终结果
List<List<Integer>> res = new ArrayList<>();
// 逐步进行枚举，确保没有重复结果，枚举第一层a
for (int first = 0; first < nums.length; first++) {
// 如果nums[first]大于0，则在first之后的数不可能存在和为0
if (nums[first] > 0) break;
// 每次枚举，相邻两个元素不能相同，确保没有重复
if (first > 0 && nums[first] == nums[first - 1]) continue;
int target = -nums[first];
// 枚举第二层b，c的初始值在数组最右端
for (int second = first + 1, third = nums.length - 1; second < nums.length; second++) {
// 保证两次枚举的元素不相同
if (second > first + 1 && nums[second] == nums[second - 1]) continue;
// 需要确保second在third的左侧
while (second < third && nums[second] + nums[third] > target) {
third--;
}
// 如果指针重合，随着b后续的增加，也不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
if (second == third) {
break;
}
if (nums[second] + nums[third] == target) {
List<Integer> list = new ArrayList<>();
list.add(nums[first]);
list.add(nums[second]);
list.add(nums[third]);
res.add(list);
}
}
}
return res;
}（2） 排序 + 双指针第二版
思路：双指针动态消去无效解来优化。同样先将nums排序。固定3个指针中第一重枚举的指针k，双指针i,j分别设在数组索引（k,len(nums)）两端。双指针i,交替向中间移动，记录对于每个固定指针k的所有满足nums[k]+nums[i]+nums[j]==0的i,j组合：
- 当nums[k]>0时直接break跳出循环：因为nums[j]≥nums[i]≥nums[k]>0，即三个元素都大于0，在此固定指针k之后不可能再找到满足条件的结果了。
- 当k>0且nums[k]==nums[k-1]时continue跳过此元素nums[k],因为已经将nums[k-1]的所有组合加入到结果中了，本次双指针搜索得到的结果是重复的。
- i,j分设在数组索引（k,len(nums)）两端，当i<j时循环计算s = nums[k]+nums[i]+nums[j]，并按照以下规则执行双指针的移动：
- 当s<0时，i+=1并跳过所有重复的nums[i];
- 当s>0时，j-=1并跳过所有重复的nums[j];
- 当s==0时，记录组合[k,i,j]到result中，执行i+=1和j-=1并跳过所有重复的nums[i]和nums[j]，防止记录到重复组合。
Java实现代码
public static List<List<Integer>> threeSum(int[] nums) {
// 先对数组进行排序
Arrays.sort(nums);
// 新建变量存储最终结果
List<List<Integer>> result = new ArrayList<>();
int n = nums.length;
// 从小到大对变量进行枚举
for (int k = 0; k < n; k++) {
// 定义左右指针i,j
int i = k + 1, j = n - 1;
if (nums[k] > 0) {
// 不可能存在满足条件的结果了，跳出循环
break;
}
if (k > 0 && nums[k] == nums[k - 1]) {
// 跳过重复的枚举元素
continue;
}
while(i < j){
int s = nums[k] + nums[i] + nums[j];
if (s < 0) {
// 移动左指针，并去重
while(i<j && nums[i] == nums[++i]);
} else if (s > 0) {
// 移动右指针，并去重
while (i < j && nums[j] == nums[--j]);
}else{
List<Integer> list = new ArrayList<>();
list.add(nums[k]);
list.add(nums[i]);
list.add(nums[j]);
result.add(list);
while(i < j && nums[i] == nums[++i]);
while(i < j && nums[j] == nums[--j]);
}
}
}
return result;
}补充：
- nums[i++]的操作是先使用变量i的当前值来获取数组nums中的元素，然后再将i的值加1。这意味着，该操作会先返回nums[i]，然后将i增加1。
- nums[++i]的操作则是先将i的值加1，然后再使用新的值来获取数组nums中的元素。也就是说，该操作会先将i增加1，然后返回nums[i]。
扫一扫
511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
