题目 1：移除有序数组中的重复元素
题目描述
给定一个升序排列的数组nums，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。不要使用额外的数组空间，必须在原地修改输入数组并在使用 O (1) 额外空间的条件下完成。
解题思路
采用快慢双指针法：
- 慢指针
slow指向当前已去重数组的最后一个位置 - 快指针
fast遍历整个数组 - 当
nums[fast]与nums[slow]不相等时，说明遇到了新元素，将慢指针后移一位，把快指针的值复制到慢指针位置 - 最终慢指针索引 + 1 就是去重后的数组长度
代码实现
cpp
运行
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; }复杂度分析
- 时间复杂度：O (n)，仅遍历数组一次
- 空间复杂度：O (1)，原地修改，无额外空间开销
面试考点
双指针思想是数组题的核心技巧，面试官常延伸问：如果允许每个元素最多出现 2 次怎么改？只需将判断条件改为nums[fast] != nums[slow-1]即可。
题目 2：旋转数组
题目描述
给定一个数组，将数组中的元素向右移动k个位置，其中k是非负数。要求使用空间复杂度 O (1)的原地算法解决。
解题思路
经典三次反转法，无需额外空间：
- 先反转整个数组
- 反转前 k 个元素
- 反转后 n-k 个元素 注意：k 可能大于数组长度，需要先对 k 取模
k %= n。
代码实现
cpp
运行
void reverse(vector<int>& nums, int left, int right) { while (left < right) { swap(nums[left], nums[right]); left++; right--; } } void rotate(vector<int>& nums, int k) { int n = nums.size(); k %= n; reverse(nums, 0, n - 1); // 反转整个数组 reverse(nums, 0, k - 1); // 反转前k个 reverse(nums, k, n - 1); // 反转后n-k个 }复杂度分析
- 时间复杂度：O (n)，每个元素被反转两次，总操作次数为 2n
- 空间复杂度：O (1)，原地操作
面试考点
考察数组的原地操作技巧。面试官常追问：向左旋转怎么实现？如果用额外数组怎么写？对比不同方案的时空开销。
题目 3：最长公共前缀
题目描述
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
解题思路
纵向扫描法： 以第一个字符串为基准，逐字符检查其他所有字符串在该位置是否相同，遇到不同字符或某字符串提前结束时停止，返回当前前缀。
代码实现
cpp
运行
string longestCommonPrefix(vector<string>& strs) { if (strs.empty()) return ""; // 以第一个字符串为基准 for (int i = 0; i < strs[0].size(); i++) { char c = strs[0][i]; // 检查其他所有字符串的第i位 for (int j = 1; j < strs.size(); j++) { // 其他字符串长度不足i，或字符不相等 if (i == strs[j].size() || strs[j][i] != c) { return strs[0].substr(0, i); } } } return strs[0]; }复杂度分析
- 时间复杂度：O (m*n)，m 是字符串平均长度，n 是字符串数量
- 空间复杂度：O (1)
面试考点
考察字符串边界处理能力。延伸问法：用分治法怎么实现？字典树（Trie）解法的优劣？
题目 4：两数之和
题目描述
给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案，且同一个元素不能重复使用。
解题思路
哈希表一次遍历法： 遍历数组时，用哈希表存储「元素值 → 索引」的映射。对于当前元素nums[i]，检查target - nums[i]是否在哈希表中：
- 存在：直接返回两个索引
- 不存在：将当前元素和索引存入哈希表，继续遍历
代码实现
cpp
运行
vector<int> twoSum(vector<int>& nums, int target) { unordered_map<int, int> hash; for (int i = 0; i < nums.size(); i++) { int complement = target - nums[i]; if (hash.count(complement)) { return {hash[complement], i}; } hash[nums[i]] = i; } return {}; }复杂度分析
- 时间复杂度：O (n)，仅遍历一次，哈希表查找为 O (1)
- 空间复杂度：O (n)，哈希表最多存储 n 个元素
面试考点
考察空间换时间的优化思想。面试官常对比：暴力法 O (n²)、排序 + 双指针法、哈希表法三种方案的优劣与适用场景。
文档 2：链表专项面试题
题目 1：反转单链表
题目描述
给你单链表的头节点head，请你反转链表，并返回反转后的链表。分别用迭代和递归两种方式实现。
解题思路
迭代法（三指针）： 用三个指针prev、curr、next遍历链表，逐个改变节点的 next 指向，最终 prev 成为新的头节点。
递归法： 递归反转当前节点之后的子链表，然后将当前节点的下一个节点的 next 指向当前节点，当前节点的 next 置空。
代码实现
cpp
运行
struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(nullptr) {} }; // 迭代法 ListNode* reverseList(ListNode* head) { ListNode* prev = nullptr; ListNode* curr = head; while (curr) { ListNode* next = curr->next; // 保存下一个节点 curr->next = prev; // 反转指针 prev = curr; // prev后移 curr = next; // curr后移 } return prev; } // 递归法 ListNode* reverseList(ListNode* head) { if (!head || !head->next) return head; ListNode* newHead = reverseList(head->next); head->next->next = head; head->next = nullptr; return newHead; }复杂度分析
- 迭代法：时间 O (n)，空间 O (1)
- 递归法：时间 O (n)，空间 O (n)（递归栈开销）
面试考点
链表基础必考题。面试官常延伸：反转链表的前 k 个节点？反转指定区间内的链表？
