我的主页:2的n次方_
1. 双指针算法
双指针算法是一种在数组或字符串中常用且高效的算法技术,它通过维护两个指针(或索引)来遍历数据结构,从而解决某些问题。这种算法能够减少不必要的重复遍历,降低时间复杂度,并且往往能够使得代码更加简洁易懂。
根据指针的的移动方向可以分为同向双指针,相向双指针,快慢指针
2. 同向双指针
2.1 移动零
思路:定义dest,cur两个指针,用cur从前往后遍历数组
维护三个区间 0~dest为非0元素 , dest + 1 ~ cur -1 都为0 ,cur ~ n-1为待处理元素
class Solution {
public void moveZeroes(int[] nums) {
int dest = -1, cur = 0;
while (cur != nums.length) {
if (nums[cur] == 0) {
cur++;
} else {
dest++;
swap(nums, cur, dest);
cur++;
}
}
}
public void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
2.2 复写零
如果使用双指针从前往后进行维护,那么会把原来数组中的值覆盖掉,造成数据混乱,所以可以尝试采用从后往前覆盖的方法
思路:先找到最后一个复写的数,然后从后往前判断复写边界问题,如果最后一个复写的数为0,意味着 dest需要往后移动两位,此时就会造成越界修改,此时就需要进行判断,但不能通过 arr[cur]来判断,需要根据dest的位置来判读,因为arr[cur]为0时也存在两种情况:dest往后移动两位刚好等于数组长度或超出一个数组长度
class Solution {
public void duplicateZeros(int[] arr) {
//找到最后一个复写的0
int dest = -1, cur = 0;
while (dest < arr.length - 1) {
if (arr[cur] == 0) {
dest += 2;
cur++;
} else {
dest++;
cur++;
}
}
cur--;
//处理边界情况
if (dest == arr.length) {
arr[dest - 1] = 0;
dest -= 2;
cur--;
}
//进行复写
while (cur != -1) {
if (arr[cur] == 0) {
arr[dest] = 0;
arr[dest - 1] = 0;
dest -= 2;
cur--;
} else {
arr[dest] = arr[cur];
dest--;
cur--;
}
}
}
}
3. 快慢指针
3.1 快乐数
证明一定会出现循环:题中给出的数据范围是int的最大值,就按照9e9来说,每一位平方求和为729,所以一定会有重复的数据
这种形状就类似于之前做过的环形链表,那道题就是利用了快慢指针,这道题同样可以使用快慢指针,但并不是传统意义上的两个指针进行移动,而是根据对当前数字操作的次数来抽象为快慢指针
既然快乐数一定可以成环,所以只需要判断环里面的数字是否是1即可
class Solution {
public boolean isHappy(int n) {
int slow = n, fast = squareSum(n);
while (slow != fast) {
slow = squareSum(slow);
fast = squareSum(squareSum(fast));
}
return slow == 1;
}
public int squareSum(int n) {
int sum = 0;
while (n > 0) {
int tmp = n % 10;
sum += tmp * tmp;
n /= 10;
}
return sum;
}
}
4. 相向指针
4.1 盛水最多的容器
如果直接进行暴力枚举出所有组合,那么一定会超时的,通过双指针可以对其进行优化
思路:先找一段区间进行分析,发现对于左右两端最小的数来说的话,继续向内模拟,无论是找到比这个数小的还是大的,都会使最终结果变小(找到小的数肯定会变小,找到大的数高度不变,宽度变小,最终还是变小),所以根据单调性,从整个区间开始,每次舍弃较小的,依次来得到不同的组合,最后比较结果最大的组合
class Solution {
public int maxArea(int[] height) {
int left = 0, right = height.length - 1;
int max = 0;
while (left != right) {
max = Math.max(max,(right - left) * Math.min(height[left], height[right]));
if (height[left] > height[right]) {
right--;
} else {
left++;
}
}
return max;
}
}
4.2 有效三角形的个数
如果正常暴力枚举,三层循环的时间复杂度就太慢了
思路:
这里进行一个优化:先把数组排序,已经排好序的三个数中,较小的两个数之和大于最长的那条边,就可以判断为三角形还是通过双指针,从后往前,先确定一个最长的边,然后从剩下的区间中开始判断,由于已经排好序了,所以如果最小的那个数加起来就已经大于第三边,那么剩下的所有就都符合,同理,此时再把右指针左移,确定下一个区间
class Solution {
public int triangleNumber(int[] nums) {
int res = 0;
Arrays.sort(nums);
for (int cur = nums.length - 1; cur >= 2; cur--) {
int left = 0, right = cur - 1;
while (left < right) {
if (nums[left] + nums[right] > nums[cur]) {
res += right - left ;
right--;
} else {
left++;
}
}
}
return res;
}
}
4.3 查找总价格为目标值的两个商品(两数之和)
也就是两数之和的问题,由于已经是排好顺序的数组,并且返回任意结果都行,通过使用双指针,如果left + right小于目标值,就把left左移,反之,把right右移
class Solution {
public int[] twoSum(int[] price, int target) {
int left = 0, right = price.length - 1;
int[] res = new int[2];
while (left < right) {
if (price[left] + price[right] > target) {
right--;
} else if (price[left] + price[right] < target) {
left++;
} else {
res[0] = price[left];
res[1] = price[right];
break;
}
}
return res;
}
}
4.4 三数之和
思路:先进行排序,然后确定一个数,剩下的两个数按照两数之和的方法解决
去重:由于已经排好顺序了,所以当找到一个符合条件的组合之后,左右两个指针之后代表的数之后的数如果相同,那么肯定就会重复,只需要把这些数跳过去,或者使用容器去重
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
Arrays.sort(nums);
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < nums.length - 2; ) {
//由于所有和为0,所以确定的最小的那个数必须要是负数
if (nums[i] > 0) {
break;
}
//两数之和
int left = i + 1, right = nums.length - 1;
while (left < right) {
if (nums[left] + nums[right] < -nums[i]) {
left++;
} else if (nums[left] + nums[right] + nums[i] == 0) {
List<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[left]);
list.add(nums[right]);
ans.add(list);
left++;
right--;
//左右两边去重
while (left < right && nums[left - 1] == nums[left]) {
left++;
}
while (right > left && nums[right + 1] == nums[right]) {
right--;
}
} else {
right--;
}
}
//确定好的那个数去重
i++;
while (i + 1 < nums.length - 1 && nums[i - 1] == nums[i]) {
i++;
}
}
return ans;
}
}
4.5 四数之和
四数之和也就是在三数之和的基础上再确定一个数,需要注意的是,此时需要去重的点有:第一个确定的数和第二个确定的数,进行双指针算法时的left和right
class Solution {
public List<List<Integer>> fourSum(int[] nums, long target) {
Arrays.sort(nums);
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < nums.length - 3; ) {
for (int j = i + 1; j < nums.length - 2; ) {
int left = j + 1, right = nums.length - 1;
while (left < right) {
if (nums[left] + nums[right] < target - nums[i] - nums[j]) {
left++;
} else if (nums[left] + nums[right] > target - nums[i] - nums[j]) {
right--;
} else {
List<Integer> list = new ArrayList<>();
list.add(nums[i]);
list.add(nums[j]);
list.add(nums[left]);
list.add(nums[right]);
ans.add(list);
left++;
right--;
//双指针去重
while (left < right && nums[left - 1] == nums[left]) {
left++;
}
while (left < right && nums[right + 1] == nums[right]) {
right--;
}
}
}
//第二个确定的数去重
j++;
while (j + 1 < nums.length - 1 && nums[j - 1] == nums[j]) {
j++;
}
}
//第一个确定的数去重
i++;
while (i + 1 < nums.length - 2 && nums[i - 1] == nums[i]) {
i++;
}
}
return ans;
}
}