双指针(Two Pointers)

双指针顾名思义，就是同时使用两个指针，在序列、链表结构上指向的是位置，在树、图结构中指向的是节点，通过或同向移动，或相向移动来维护、统计信息。

如果不和其他数据结构结合使用，双指针维护区间信息的最简单模式就是维护具有一定单调性，新增和删去一个元素都很方便处理的信息，就比如正数的和、正整数的积等等。(本文章不涉及其它数据结构的结合，仅解释什么是双指针，以及相关代码)

问题：

给定一个已排序的数组，我们需要在原地删除重复出现的元素，使每个元素只出现一次，并返回新的长度。不要使用额外的数组空间，必须在原地修改输入数组，并在 O(1) 额外空间的条件下完成。

示例：

输入: nums = [1, 1, 2, 3, 3, 4, 5, 5, 6]

输出: length = 6， nums = [1, 2, 3, 4, 5, 6]

注意：本题有很多方法，但只对双指针方法进行了解

双指针：一个快指针，一个慢指针

使用vector保存数据，并且此数据已经排序

vector<int> nums = {[1, 1, 2, 3, 3, 4, 5, 5, 6]};

 

1. 首先，我们有两个指针：一个指向当前不重复元素应该存放的位置，称为慢指针（slow pointer），初始时指向数组的起始位置；另一个用于遍历数组，称为快指针（fast pointer），初始时指向数组的第二个位置。

2. 慢指针指向数组的第一个位置，快指针指向数组的第二个位置。比较慢指针和快指针所指向的元素是否相同。

   [1, 2, 2, 3, 3, 4, 5, 5, 6]
       ↑     ↑
       slow  fast
   

3. 因为快指针和慢指针所指向的元素相同，所以快指针继续向后移动。

   [1, 1, 2, 3, 3, 4, 5, 5, 6]
    ↑     ↑
    slow  fast
   

4. 快指针继续向后移动。

   [1, 1, 2, 3, 3, 4, 5, 5, 6]
    ↑        ↑
    slow     fast
   

5. 快指针指向的元素不同于慢指针，因此将快指针指向的元素复制到慢指针的下一个位置，并将慢指针向后移动一步。

   [1, 2, 2, 3, 3, 4, 5, 5, 6]
       ↑     ↑
       slow  fast
   

6. 快指针继续向后移动。

   [1, 2, 2, 3, 3, 4, 5, 5, 6]
       ↑        ↑
       slow     fast
   

7. 继续上述步骤，直到快指针遍历完整个数组。

   [1, 2, 3, 3, 3, 4, 5, 5, 6]
          ↑        ↑
          slow     fast
   

8. 最终，慢指针指向的位置即为去重后数组的末尾位置，慢指针位置加 1 即为去重后数组的长度。

代码实现

int removeDuplicates(vector<int>& nums) {
    if (nums.empty()) {
        return 0;
    }

    int slow = 0; // 慢指针，用于记录不重复元素应该存放的位置

    for (int fast = 1; fast < nums.size(); ++fast) {
        if (nums[fast] != nums[slow]) {
            ++slow;
            nums[slow] = nums[fast];
        }
    }

    return slow + 1;
}

即从下标0到下标slow，为去重后的数组

问题：在有序数组中查找两数之和为目标值的索引。

问题描述：

给定一个按升序排序的整数数组 nums，以及一个目标值 target。请你在数组中找出和为目标值 target 的两个整数，并返回它们的索引，假设每个输入只对应一种答案。你可以假设数组中同一个元素不能使用两遍。

示例：

输入：nums = [2, 7, 11, 15], target = 9

输出：[0, 1]

解释：nums[0] + nums[1] = 2 + 7 = 9，因此返回 [0, 1]。

解题思路：

使用双指针算法来解决这个问题。将数组按升序排列，我们可以使用两个指针，一个指向数组的起始位置，另一个指向数组的末尾位置。然后，我们在移动指针的过程中不断地检查当前指针所指向的两个元素之和是否等于目标值。如果等于目标值，则返回这两个元素的索引；如果小于目标值，则将左指针右移一位；如果大于目标值，则将右指针左移一位。直到找到符合条件的解或者左右指针相遇为止。(这道题不适合像上一题从0，1开始遍历)

代码实现

#include <iostream>
#include <vector>

using namespace std;

vector<int> twoSum(vector<int>& nums, int target) {
    int left = 0, right = nums.size() - 1;
    
    while (left < right) {
        int current_sum = nums[left] + nums[right];
        if (current_sum == target) {
            return {left, right}; // 找到目标值，返回索引
        } else if (current_sum < target) {
            left++; // 如果和小于目标值，则左指针右移
        } else {
            right--; // 如果和大于目标值，则右指针左移
        }
    }
    
    return {}; // 如果找不到符合条件的索引，则返回空向量
}

int main() {
    vector<int> nums = {2, 7, 11, 15};
    int target = 9;
    vector<int> result = twoSum(nums, target);
    cout << "[" << result[0] << ", " << result[1] << "]" << endl; // 输出 [0, 1]，因为 nums[0] + nums[1] = 2 + 7 = 9
    return 0;
}