双指针秒杀七道数组题目

删除有序数组中的重复项

简单解释一下什么是原地修改：

如果不是原地修改的话，我们直接 new 一个 int[] 数组，把去重之后的元素放进这个新数组中，然后返回这个新数组即可。

但是现在题目让你原地删除，不允许 new 新数组，只能在原数组上操作，然后返回一个长度，这样就可以通过返回的长度和原始数组得到我们去重后的元素有哪些了。

由于数组已经排序，所以重复的元素一定连在一起，找出它们并不难。但如果毎找到一个重复元素就立即原地删除它，由于数组中删除元素涉及数据搬移，整个时间复杂度是会达到 O(N^2)。

高效解决这道题就要用到快慢指针技巧：

我们让慢指针 slow 走在后面，快指针 fast 走在前面探路，找到一个不重复的元素就赋值给 slow 并让 slow 前进一步。

这样，就保证了 nums[0..slow] 都是无重复的元素，当 fast 指针遍历完整个数组 nums 后，nums[0..slow] 就是整个数组去重之后的结果。

#include <stdio.h>

int removeDuplicates(int* nums, int numsSize) {
if (numsSize == 0) {
return 0;
}
int slow = 0, fast = 0;
while (fast < numsSize) {
if (nums[fast] != nums[slow]) {
slow++;
// 维护 nums[0..slow] 无重复
nums[slow] = nums[fast];
}
fast++;
}
// 数组长度为索引 + 1
return slow + 1;
}

int main() {
int nums[] = {1, 1, 2, 2, 3, 4, 4, 5};
int numsSize = sizeof(nums) / sizeof(nums[0]);

int result = removeDuplicates(nums, numsSize);

printf("Result: %d\n", result);
printf("Array after removing duplicates: ");
for (int i = 0; i < result; i++) {
printf("%d ", nums[i]);
}

return 0;
}

再简单扩展一下，看看力扣第 83 题「删除排序链表中的重复元素」，如果给你一个有序的单链表，如何去重呢？

其实和数组去重是一模一样的，唯一的区别是把数组赋值操作变成操作指针而已，你对照着之前的代码来看：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
struct ListNode {
int val;
struct ListNode* next;
};

// 删除重复元素
struct ListNode* deleteDuplicates(struct ListNode* head) {
if (head == NULL) return NULL;
struct ListNode* slow = head;
struct ListNode* fast = head->next;
while (fast != NULL) {
if (fast->val != slow->val) {
slow->next = fast;
slow = slow->next;
}
fast = fast->next;
}
slow->next = NULL;
return head;
}

// 创建链表节点
struct ListNode* createNode(int val) {
struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
newNode->val = val;
newNode->next = NULL;
return newNode;
}

// 打印链表
void printList(struct ListNode* head) {
struct ListNode* curr = head;
while (curr != NULL) {
printf("%d ", curr->val);
curr = curr->next;
}
printf("\n");
}

int main() {
// 创建链表
struct ListNode* head = createNode(1);
head->next = createNode(1);
head->next->next = createNode(2);
head->next->next->next = createNode(3);
head->next->next->next->next = createNode(3);

printf("Original List: ");
printList(head);

// 删除重复元素
struct ListNode* newHead = deleteDuplicates(head);

printf("List after deleting duplicates: ");
printList(newHead);

return 0;
}

这里可能有读者会问，链表中那些重复的元素并没有被删掉，就让这些节点在链表上挂着，合适吗？

这就要探讨不同语言的特性了，像 Java/Python 这类带有垃圾回收的语言，可以帮我们自动找到并回收这些「悬空」的链表节点的内存，而像 C++ 这类语言没有自动垃圾回收的机制，确实需要我们编写代码时手动释放掉这些节点的内存。

不过话说回来，就算法思维的培养来说，我们只需要知道这种快慢指针技巧即可。

除了让你在有序数组/链表中去重，题目还可能让你对数组中的某些元素进行「原地删除」。比如力扣第 27 题「移除元素」，

移除元素

题目要求我们把 nums 中所有值为 val 的元素原地删除，依然需要使用快慢指针技巧：

如果 fast 遇到值为 val 的元素，则直接跳过，否则就赋值给 slow 指针，并让 slow 前进一步。

这和前面说到的数组去重问题解法思路是完全一样的，就不画 GIF 了，直接看代码：

#include <stdio.h>

int removeElement(int* nums, int numsSize, int val) {
int fast = 0, slow = 0;
while (fast < numsSize) {
if (nums[fast] != val) {
nums[slow] = nums[fast];
slow++;
}
fast++;
}
return slow;
}

int main() {
int nums[] = {3, 2, 2, 3, 3, 4, 5, 3, 6};
int val = 3;
int numsSize = sizeof(nums) / sizeof(nums[0]);

printf("Original Array: ");
for (int i = 0; i < numsSize; i++) {
printf("%d ", nums[i]);
}
printf("\n");

int newSize = removeElement(nums, numsSize, val);

printf("New Array after removing %d: ", val);
for (int i = 0; i < newSize; i++) {
printf("%d ", nums[i]);
}
printf("\n");

return 0;
}

注意这里和有序数组去重的解法有一个细节差异，我们这里是先给 nums[slow] 赋值然后再给 slow++，这样可以保证 nums[0..slow-1] 是不包含值为 val 的元素的，最后的结果数组长度就是 slow。

实现了这个 removeElement 函数，接下来看看力扣第 283 题「移动零」：

移动0

比如说给你输入 nums = [0,1,4,0,2]，你的算法没有返回值，但是会把 nums 数组原地修改成 [1,4,2,0,0]。

结合之前说到的几个题目，你是否有已经有了答案呢？

题目让我们将所有 0 移到最后，其实就相当于移除 nums 中的所有 0，然后再把后面的元素都赋值为 0 即可。

所以我们可以复用上一题的 removeElement 函数：

#include <stdio.h>

// 删除特定元素
int removeElement(int* nums, int numsSize, int val) {
int fast = 0, slow = 0;
while (fast < numsSize) {
if (nums[fast] != val) {
nums[slow] = nums[fast];
slow++;
}
fast++;
}
return slow;
}

// 移动零
void moveZeroes(int* nums, int numsSize) {
int p = removeElement(nums, numsSize, 0);
for (int i = p; i < numsSize; i++) {
nums[i] = 0;
}
}

int main() {
int nums[] = {0, 1, 0, 3, 12};
int numsSize = sizeof(nums) / sizeof(nums[0]);

printf("Original Array: ");
for (int i = 0; i < numsSize; i++) {
printf("%d ", nums[i]);
}
printf("\n");

moveZeroes(nums, numsSize);

printf("New Array after moving zeroes: ");
for (int i = 0; i < numsSize; i++) {
printf("%d ", nums[i]);
}
printf("\n");

return 0;
}

到这里，原地修改数组的这些题目就已经差不多了。数组中另一大类快慢指针的题目就是「滑动窗口算法」。

左右指针的常用算法

1.二分法

int binarySearch(int* nums, int size, int target) {
int left = 0, right = size - 1;
while (left <= right) {
int mid = (right + left) / 2;
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else if (nums[mid] > target)
right = mid - 1;
}
return -1;
}

2.两数之和2

只要数组有序，就应该想到双指针技巧。这道题的解法有点类似二分查找，通过调节 left 和 right 就可以调整 sum 的大小：

#include <stdio.h>
#include <stdlib.h>

// 结构体用于存储结果的索引
typedef struct {
int index1;
int index2;
} Result;

// 两数之和函数
Result twoSum(int* nums, int size, int target) {
int left = 0, right = size - 1; // 定义左右两个指针
while (left < right) {
int sum = nums[left] + nums[right]; // 计算当前左右指针对应元素的和
if (sum == target) {
Result result; // 找到目标和，构建结果结构体并返回
result.index1 = left + 1; // 题目要求索引从1开始计数
result.index2 = right + 1;
return result;
} else if (sum < target) {
left++; // 若和小于目标值，则增大和，移动左指针
} else if (sum > target) {
right--; // 若和大于目标值，则减小和，移动右指针
}
}
Result result; // 未找到满足条件的两数和，返回{-1, -1}
result.index1 = -1;
result.index2 = -1;
return result;
}

int main() {
int nums[] = {2, 7, 11, 15}; // 测试输入数组
int size = sizeof(nums) / sizeof(nums[0]); // 数组大小
int target = 9; // 目标值

Result result = twoSum(nums, size, target); // 调用两数之和函数
if (result.index1 != -1 && result.index2 != -1) // 判断是否找到满足条件的结果
printf("The two numbers at indices %d and %d add up to the target.", result.index1, result.index2);
else
printf("No two numbers add up to the target."); // 输出结果

return 0;
}

3.反转数组

#include <stdio.h>
#include <stdlib.h>

void reverseString(char* s, int size) {
int left = 0, right = size - 1;
while (left < right) {
char temp = s[left];
s[left] = s[right];
s[right] = temp;
left++;
right--;
}
}

int main() {
char str[] = "Hello, World!"; // 测试输入字符串
int size = sizeof(str) - 1; // 字符串长度（去除'\0'）

printf("Before reverse: %s\n", str); // 输出原始字符串
reverseString(str, size); // 调用字符串反转函数
printf("After reverse: %s\n", str); // 输出反转后的字符串

return 0;
}

回文串判断

首先明确一下，回文串就是正着读和反着读都一样的字符串。

比如说字符串 aba 和 abba 都是回文串，因为它们对称，反过来还是和本身一样；反之，字符串 abac 就不是回文串。

现在你应该能感觉到回文串问题和左右指针肯定有密切的联系，比如让你判断一个字符串是不是回文串，你可以写出下面这段代码：

bool isPalindrome(char *s) {
int left = 0, right = strlen(s) - 1; // 获取字符串的长度
while (left < right) {
if (s[left] != s[right]) { // 如果不相同，就不是回文串
return false;
}
left++;
right--;
}
return true;
}