算法入门第三天——双指针

283. 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

 

使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。

右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。

注意到以下性质：

左指针左边均为非零数；

右指针左边直到左指针处均为零。

因此每次交换，都是将左指针的零与右指针的非零数交换，且非零数的相对顺序并未改变。

复杂度分析

时间复杂度：O(n)O(n)O(n)，其中 nnn 为序列长度。每个位置至多被遍历两次。

空间复杂度：O(1)O(1)O(1)。只需要常数的空间存放若干变量。

1. 非0，交换数据，左右指针都往右移
2. 0，右指针右移

void swap(int *a, int *b) {
    int t = *a;
    *a = *b, *b = t;
}

void moveZeroes(int *nums, int numsSize) {
    int left = 0, right = 0;
    while (right < numsSize) {
        if (nums[right]) {
            swap(nums + left, nums + right);
            left++;
        }
        right++;
    }
}

right下标遍历数组，left下标指向要赋值的位置 遍历数组，把每一个不为零的数赋值给left，直接在原数组上覆盖，更新数组 eg：1 0 0 2 3 5 6 1 2 3 5 6 5 6 最后(left < numsSize)位置给零

void moveZeroes(int *nums, int numsSize) {
    int left = 0, right = 0;

    while (right < numsSize)
    {
        if(nums[right]!=0)
        {
            nums[left]=nums[right];//覆盖
            left++;//更新后更新位置往后移
        }
        right++;
    }//遍历每一个不为零的数并在原数组上进行覆盖，最后没有覆盖的位置给0

    while(left

 167. 两数之和 II - 输入有序数组

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 

方法一：二分查找
在数组中找到两个数，使得它们的和等于目标值，可以首先固定第一个数，然后寻找第二个数，第二个数等于目标值减去第一个数的差。利用数组的有序性质，可以通过二分查找的方法寻找第二个数。为了避免重复寻找，在寻找第二个数时，只在第一个数的右侧寻找。

复杂度分析

时间复杂度：O(nlog⁡n)O(n \log n)O(nlogn)，其中 nnn 是数组的长度。需要遍历数组一次确定第一个数，时间复杂度是 O(n)O(n)O(n)，寻找第二个数使用二分查找，时间复杂度是 O(log⁡n)O(\log n)O(logn)，因此总时间复杂度是 O(nlog⁡n)O(n \log n)O(nlogn)。

空间复杂度：O(1)O(1)O(1)。

int* twoSum(int* numbers, int numbersSize, int target, int* returnSize) {
    int* ret = (int*)malloc(sizeof(int) * 2);
    *returnSize = 2;

    for (int i = 0; i < numbersSize; ++i) {
        int low = i + 1, high = numbersSize - 1;
        while (low <= high) {
            int mid = (high - low) / 2 + low;
            if (numbers[mid] == target - numbers[i]) {
                ret[0] = i + 1, ret[1] = mid + 1;
                return ret;
            } else if (numbers[mid] > target - numbers[i]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
    }
    ret[0] = -1, ret[1] = -1;
    return ret;
}

方法二：双指针
初始时两个指针分别指向第一个元素位置和最后一个元素的位置。每次计算两个指针指向的两个元素之和，并和目标值比较。如果两个元素之和等于目标值，则发现了唯一解。如果两个元素之和小于目标值，则将左侧指针右移一位。如果两个元素之和大于目标值，则将右侧指针左移一位。移动指针之后，重复上述操作，直到找到答案。

使用双指针的实质是缩小查找范围。那么会不会把可能的解过滤掉？答案是不会。假设 numbers[i]+numbers[j]=target\textit{numbers}[i]+\textit{numbers}[j]=\textit{target}numbers[i]+numbers[j]=target 是唯一解，其中 0≤i

如果左指针先到达下标 iii 的位置，此时右指针还在下标 jjj 的右侧，sum>target\textit{sum}>\textit{target}sum>target，因此一定是右指针左移，左指针不可能移到 iii 的右侧。

如果右指针先到达下标 jjj 的位置，此时左指针还在下标 iii 的左侧，sum

由此可见，在整个移动过程中，左指针不可能移到 iii 的右侧，右指针不可能移到 jjj 的左侧，因此不会把可能的解过滤掉。由于题目确保有唯一的答案，因此使用双指针一定可以找到答案。

复杂度分析

时间复杂度：O(n)O(n)O(n)，其中 nnn 是数组的长度。两个指针移动的总次数最多为 nnn 次。

空间复杂度：O(1)O(1)O(1)。

int* twoSum(int* numbers, int numbersSize, int target, int* returnSize) {
    int* ret = (int*)malloc(sizeof(int) * 2);
    *returnSize = 2;

    int low = 0, high = numbersSize - 1;
    while (low < high) {
        int sum = numbers[low] + numbers[high];
        if (sum == target) {
            ret[0] = low + 1, ret[1] = high + 1;
            return ret;
        } else if (sum < target) {
            ++low;
        } else {
            --high;
        }
    }
    ret[0] = -1, ret[1] = -1;
    return ret;
}

 二分查找方案中的int low = i + 1代码中，为什么需要 + 1呢？

不能找同一个数，所以从第二个开始查找

为什么 双指针方法 low=0;

虽然题目的数组从下标为1开始，但是做题的时候以习惯的下标为0开始，返回的结果+1就好了。

    int* ret = (int*)malloc(sizeof(int) * 2);
    *returnSize = 2;

 因为returnSize代表返回数组的长度。因为返回两个index，数组长度是2，所以returnSize是2。为啥用呢，因为returnSize是指针，对指针所指向的存储单元的值进行赋值，就用*。