算法——双指针算法

双指针：
把数组下标看作指针，注意数组越界问题，注意区间边界值

283.移动零

class Solution {
    public void moveZeroes(int[] nums) {
        int cur = 0;
        int dest = -1;
        while(cur < nums.length)
         if(nums[cur] != 0){
            int tmp = nums[cur];
            dest++;
            nums[cur] = nums[dest];
            cur++;
            nums[dest] = tmp;
         }
            else {
            cur++;
         }
    }
}

解题思路：

• 解法（快排的思想：数组划分区间 - 数组分两块）：
• 算法思路：
  在本题中，用⼀个 cur 指针来扫描整个数组，另一个 dest 指针用来记录非零数序列
  的最后⼀个位置。根据 cur 在扫描的过程中，遇到的不同情况，分类处理，实现数组的划分。
  在 cur 遍历期间，使 [0, dest] 的元素全部都是非零元素， [dest + 1, cur - 1] 的
  元素全是零。
• 算法流程：
  a. 初始化 cur = 0 （用来遍历数组）， dest = -1 （指向非零元素序列的最后⼀个位置。
  因为刚开始我们不知道最后⼀个非零元素在什么位置，因此初始化为 -1 ）
  b. cur 依次往后遍历每个元素，遍历到的元素会有下面两种情况：
  i. 遇到的元素是 0 ， cur 直接 ++ 。因为我们的目标是让 [dest + 1, cur - 1] 内
  的元素全都是零，因此当 cur 遇到 0 的时候，直接 ++ ，就可以让 0 在 cur - 1
  的位置上，从而在 [dest + 1, cur - 1] 内；
  ii. 遇到的元素不是 0 ， dest++ ，并且交换 cur 位置和 dest 位置的元素，之后让
  cur++ ，扫描下⼀个元素。
  因为 dest 指向的位置是非零元素区间的最后⼀个位置，如果扫描到⼀个新的非零元
  素，那么它的位置应该在 dest + 1 的位置上，因此 dest 先自增 1 ；
  dest++ 之后，指向的元素就是 0 元素（因为非零元素区间末尾的后⼀个元素就是
  0 ），因此可以交换到 cur 所处的位置上，实现 [0, dest] 的元素全部都是非零
  元素， [dest + 1, cur - 1] 的元素全是零。
• 解法二：

 class Solution
 {
 public void moveZeroes(int[] nums)
 {
 for(int cur = 0, dest = -1; cur < nums.length; cur++)
 if(nums[cur] != 0) // 仅需处理⾮零元素
 {
 dest++; // dest 先向后移动⼀位
 // 交换
 int tmp = nums[cur];
 nums[cur] = nums[dest];
 nums[dest] = tmp;
 }
 }
 }

易错点：

• 交换时切记找个中间值
• dest先自增到0，否则为-1会数组越界异常，力扣直接报错
• 数组内元素有n(nums.length)个，数组元素下标最大值为n-1，而判断条件为 cur < nums.length 的原因是: cur 需要遍历完所有元素，即cur最后 为n

1089.复写零

关键词：原数组中
思路：双指针从前向后是不正确的，后面的元素会被复写的0覆盖掉
难点：先找到最后一个要复写的数
怎么找？

• 双指针中套双指针
  • 先判断cur的值
  • 决定dest向后移动一步或者两步(0移动两步）
  • 判断一下dest是否已经结束为止
  • cur++
• 处理边界情况，倒数第二个是0的情况，dest走两步会越界
  tips：没有思路时,画图模拟
  

 class Solution
 	{
 	public 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++;
	 }
 	// 2. 处理⼀下边界情况
 	if(dest == n)
 	{
 		arr[n - 1] = 0;
 		cur--; dest -= 2;
 	}
	// 3. 从后向前完成复写操作
 	while(cur >= 0)
 	{
 		if(arr[cur] != 0) arr[dest--] = arr[cur--];
 		else
 		{
 			arr[dest--] = 0;
 			arr[dest--] = 0;
 			cur--;
 }
 }
 }
 }

算法流程：

1. 初始化两个指针 cur = 0 ， dest = 0 ；
2. 找到最后一个复写的数：
   当 cur < n 的时候，⼀直执行下面循环：
   (1)判断 cur 位置的元素:
   如果是 0 的话， dest 往后移动两位；
   否则， dest 往后移动⼀位。
   (2)判断 dest 已经到结束位置，如果结束就终止循环；
   如果没有结束， cur++ ，继续判断。
3. 判断 dest 是否越界到 n 的位置：
   如果越界，执行下面三步：
   (1)n - 1 位置的值修改成 0 ；
   (2)cur 向移动⼀步；
   (3)dest 向前移动两步。
4. 从 cur 位置开始往前遍历原数组，依次还原出复写后的结果数组：
   (1)判断 cur 位置的值：
   如果是 0 ： dest 以及 dest - 1 位置修改成 0 ， dest -= 2 ；
   如果非零： dest 位置修改成 0 ， dest -= 1 ；
   (2)cur-- ，复写下⼀个位置。