移动零
算法原理：
数组划分(数组分块)
两个指针作用：
cur：从左到右扫描数组，遍历数组
dest：已处理的区间内，非零元素的最后一个位置
三个区间：
[0.dest]:已经处理过的非零元素
[dest+1, cur-1]：处理过的零元素
[cur,n-1] ：待处理元素
情况1：当cur遇到0元素的时候，直接让cur向后移动一位
情况2：当cur遇到非零元素的时候，dest往后一位。然后交换这两个位置的元素，然后cur+1
情况3：当cur遍历到n时，就完成了区间的划分
总结：
cur从前往后遍历的过程中：
1.遇到0元素：cur元素++
2.遇到非零元素：
swap(dest+1,cur);
dest++,cur++;
代码
class Solution {
public void moveZeroes(int[] nums) {
for(int cur = 0, dest = -1; cur < nums.length; cur++) {
if(nums[cur] != 0) {
dest++;
int tmp = nums[cur];
nums[cur] = nums[dest];
nums[dest] = tmp;
}
}
}
}
复写零
算法原理：
解法：双指针算法
先根据“异地”操作，然后优化成双指针下的“就地”操作
异地操作就是说开辟一个新的数组，定义一个指针指向原始数组，定义一个新指针指向新数组，然后进行操作。
就地操作，就是把两个指针定义在同一个数组上。
1.先找到最后一个“复写”的数；
双指针算法：
1）先判断cur位置的值
2）决定dest向后移动一步或者两步
3.）判断一下dest是否已经到结束为止
4）cur++
1.5. 处理一下边界情况
n-1 -> 0
cur–
dest -=2
2.“从后向前”完成复写操作；
代码
public static void duplicateZeros(int[] arr) {
int cur = 0, dest = -1, n = arr.length;
// 1. 先找到最后一个需要复写的数
while (cur < n) {
if (arr[cur] == 0) dest += 2;
else dest += 1;
if (dest >= n - 1) break;
cur++;
}
// 1.5 处理一下边界情况
if (dest == n) {
arr[n - 1] = 0;
cur--;
dest -= 2;
}
// 2. 从后向前完成复写操作
while (cur >= 0) {
if (arr[cur] != 0) arr[dest--] = arr[cur--];
else {
arr[dest--] = 0;
arr[dest--] = 0;
cur--;
}
}
}
快乐数
算法原理：
判断链表是否有环
解法：快慢双指针
1.定义快慢指针
2.慢指针每次向后移动一步，快指针每次向后移动两步
3.判断相遇时候的值即可
代码
class Solution {
public int bitSum(int n) {
// 返回n这个数每一位上的平方和
int sum = 0;
while (n != 0) {
int t = n % 10;
sum += t * t;
n /= 10;
}
return sum;
}
public boolean isHappy(int n) {
int slow = n;
int fast = bitSum(n);
while (slow != fast) {
slow = bitSum(slow);
fast = bitSum(bitSum(fast));
}
return slow == 1;
}
}
盛最多水的容器
解法思路：
解法一：暴力枚举O(N^2)
解法二：利用单调性，使用双指针解决问题O(N)
代码
public int maxArea(int[] height) {
int left = 0;
int right = height.length - 1;
int ret = 0;
while (left < right) {
int v = Math.min(height[left], height[right]) * (right - left);
ret = Math.max(ret, v);
if (height[left] < height[right]) left++;
else right--;
}
return ret;
}
有效三角形的个数
算法原理：
利用单调性，使用双指针算法来解决问题
先对整个数组排序。
先固定最大的数
在最大的数的左区间内，使用双指针算法，快速统计出符合要求的三元组的个数
代码
import java.util.Arrays;
public class Solution {
public int triangleNumber(int[] nums) {
// 1. 优化：排序
Arrays.sort(nums);
// 2. 利用双指针解决问题
int ret = 0, n = nums.length;
for (int i = n - 1; i > 0; i--) {
// 先固定最大的数
// 利用双指针快速统计出符合三元组的个数
int left = 0, right = i - 1;
while (left < right) {
if (nums[left] + nums[right] > nums[i]) {
ret += right - left;
right--;
} else {
left++;
}
}
}
return ret;
}
}
和为s的两个数
算法原理：
利用单调性，使用双指针算法解决问题
代码
public int[] twoSum(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left < right) {
int sum = nums[left] + nums[right];
if (sum > target) right--;
else if (sum < target) left++;
else return new int[]{
nums[left], nums[right]};
}
// 照顾编译器
return new int[]{
0};
}
三数之和
算法原理：
排序+双指针
1.排序；
2.固定一个数i
3.在该数后面的区间内，利用“双指针算法”，快速找到两个的和等于-i即可
处理细节：
1.去重 ：找到一种结果之后，left和right指针要跳过重复元素；当使用完一次双指针算法之后，i也需要跳过重复元素
2.不漏 ： 找到一种结果之后，不要”停“，缩小区间，继续寻找
代码
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> ret = new ArrayList<>();
// 1. 排序
Arrays.sort(nums);
// 2. 利于双指针解决问题
int n = nums.length;
for (int i = 0; i < n;) {
//固定数 a
if (nums[i] > 0) break;// 小优化
int left = i + 1;
int right = n - 1, target = -nums[i];
while (left < right) {
int sum = nums[left] + nums[right];
if (sum > target) right--;
else if (sum < target) left++;
else {
// nums[i] nums[left] nums[right]
ret.add(new ArrayList<Integer>(Arrays.asList(nums[i], nums[left], nums[right])));
// 缩小区间，继续寻找
left++;
right--;
// 去重
while (left < right && nums[left] == nums[left - 1]) {
left++;
}
while (left < right && nums[right] == nums[right + 1]) {
right--;
}
}
}
// 去重： i
i++;
while (i < n && nums[i] == nums[i - 1]) i++;
}
return ret;
}
}
四数之和
算法原理：
排序+双指针
1.依次固定一个数a；
2.在a后面的区间内，利用“三数之和“找到三个数，使这三个数的和等于 target-a即可
代码
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> ret = new ArrayList<>();
// 1. 排序
Arrays.sort(nums);
// 2. 利用双指针解决问题
int n = nums.length;
for (int i = 0; i < n; ) {
// 固定数a
// 三数之和
for (int j = i + 1; j < n; ) {
// 固定数 b
// 双指针
int left = j + 1, right = n - 1;
long aim = (long)target - nums[i] - nums[j];
while (left < right) {
int sum = nums[left] + nums[right];
if (sum > aim) right--;
else if (sum < aim) left++;
else {
ret.add(Arrays.asList(nums[i], nums[j], nums[left++], nums[right--]));
// 去重一
while (left < right && nums[left] == nums[left - 1]) left++;
while (left < right && nums[right] == nums[right + 1]) right--;
}
}
// 去重二
j++;
while (j < n && nums[j] == nums[j - 1]) j++;
}
// 去重三
i++;
while (i < n && nums[i] == nums[i - 1]) i++;
}
return ret;
}