大家好，我是程序员牛奶，这篇文章讲解的内容是双指针技巧的相关习题。读完这篇文章可以去解决以下题目：

Reverse String 344. 反转字符串🟢Easy

网站	题目	难度
LeetCode	Remove Duplicates from Sorted Array 26. 删除有序数组中的重复项🟢	Easy
LeetCode	Remove Duplicates from Sorted List 83. 删除排序链表中的重复元素🟢	Easy
LeetCode	Remove Element 27. 移除元素🟢	Easy
LeetCode	Move Zeroes 283. 移动零🟢	Easy
LeetCode	Two Sum II - Input Array Is Sorted 167. 两数之和 II - 输入有序数组🟡	Medium
LeetCode
LeetCode	Longest Palindromic Substring 5. 最长回文子串🟡	Medium

前置知识

阅读这篇文章前，你需要先学习我的单链表双指针相关的算法内容。

全局地图

在处理数组和链表相关问题时双指针技巧是经常用到的，主要分为两类：

• 左右指针：两个指针相向而行或者相背而行。
• 快慢指针：两个指针同向而行，一快一慢。

对于单链表大部分技巧都属于快慢指针，比如链表环判断、倒数第 K 个节点等。在数组中没有真实的指针，但可以把索引当做指针，一样施展双指针技巧。这篇文章主要讲数组相关的双指针算法。怎么说呢，

一、快慢指针技巧

通用模板 & 痛点剖析

痛点： 很多同学在面对「原地删除」或「原地修改」时会直接使用额外数组或频繁的.remove导致 O 的时间复杂度。下面的模板帮助你一次遍历搞定。

int slow = 0,fast = 0;while {
if {
nums = nums;slow++，}
fast++;}
// slow 即为结果长度

从主要思想来看。fast 负责探路遍历整个数组，slow 负责维护结果边界。只有满足条件时才把元素「收录」到slow 位置，从而避免不必要的数据搬移。

1️⃣ 删除有序数组中的重复项

Pain point： 如果每发现一个重复就立刻使用.remove会导致 O 的时间开销。

利用快慢指针，只需要一次遍历就可以完成去重：

class Solution {
public int removeDuplicates {
if return 0;int slow = 0,fast = 1;老实说，while {
if {
slow++;// 先移动到下一个空位
nums = nums;// 再写入新值
}
fast++;}
return slow + 1;// 索引 +1 才是长度
}
}

2️⃣ 删除排序链表中的重复元素

Pain point： 不少人对链表去重仍然坚持创建新链表，浪费空间。实际只需要改动指针即可，

class Solution {
public ListNode deleteDuplicates {
if return null;ListNode slow = head,fast = head;while {
if {
slow.next = fast;// 把新节点接到结果链表尾部
slow = slow.next;}
fast = fast.next;}
slow.next = null;// 防止残留旧节点
return head;怎么说呢，}
}

3️⃣ 移除元素

Pain point： 很多人误以为必须先找出所有要删除的下标再统一处理。只要一次遍历即可，

class Solution {
public int removeElement {
int fast = 0,slow = 0;while {
if { // 非目标值才保留
nums = nums;slow++，}
fast++;}
return slow;// 新长度
}
}

4️⃣ 移动零

Pain point： 不少同学会写两次循环：一次搬非零，一次填零。其实可以复用上面的#removeElement框架，让代码更简洁。

class Solution {
public void moveZeroes {
// 第一步先：把所有非零元素搬到左侧，返回新长度 p
int p = removeElement;// 接下来：把剩余位置全部填充为零
for {
nums = 0;}
}
private int removeElement {
int fast = 0,slow = 0;怎么说呢，while {
if {
nums = nums;}
fast++，}
return slow;话说回来，}
}

滑动窗口

If you need to handle “子数组/子串 + 条件约束”。滑动窗口提供了一个天然的快慢指针框架。感兴趣的同学可参考我的《滑动窗口算法主要框架详解》章节。

二、左右指针常用算法

Pain point： 面对有序数组求和、配对等问题时很多人第一反应是二重循环 O。只需要左右两端各一根指针即可线性完成。

int left = 0,right = nums.length - 1;其实，while {
if { return ...;}
else if { left++;}
else { right--;}
}
return -1;// 未找到
}

5️⃣ 两数之和 II - 输入有序数组

This problem perfectly illustrates left‑right technique.

class Solution { public int twoSum { int left = 0,right = numbers.length - 1;while { int sum = numbers + numbers;if return new int{left + 1,right + 1};else if left++;// sum 太小，需要更大的左侧数 else right--;// sum 太大，需要更小的右侧数 } return new int{-1,-1};} }

6️⃣ 原地反转字符串

The most straightforward application of left‑right pointers.

void reverseString{ int left=0,right=s.length-1;怎么说呢，while{ char tmp=s;s=s，s=tmp;left++，right--;} }

7️⃣ 最长回文子串

The “中心 ”方式仍然使用左右指针。只但是它们从中心*向外*展开**而不是相向而行，这也是一种特殊的左右指针对称运动。

class Solution{ public String longestPalindrome{ String best="";for，i++){ String odd=expand;// 奇数长度中心 String even=expand;// 偶数长度中心 best=best.length>odd.length?best:odd，best=best.length>even.length?best:even，} return best;}

private String expand{ while && s.charAt==s.charAt){ l--;r++，} return s.substring;} }

The algorithm runs in O. For interview purposes this is sufficient—if you crave O,study Manacher’s algorithm.

与实战方法图

...

题目类型 / 场景​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ ​‌‍‌‍‍‍‍‍‌‍‌‌‍‌‌‌‌‌‏‏‏‏‏‏‏‏‏‎‎‎‎‎‎‎‎ ‎‎ ‎	对应指针类型	主要判断条件	返回值/意义	常见痛点	快速定位思路
`删除有序数组中的重复项` | `删除排序链表中的重复元素` | `移除元素` | `移动零`	`快慢` `slow ← result boundary`	`nums!=nums` or `nums!=val`	`new length`	`误以为要 new 数组 / O`	`套模板① → 替换判断条件即可`
`两数之和 II - 输入有序数组`	`左右相向` `left←start,right←end`	`sum 与 target 大小比较`	`下标 pair`	`直接暴力双循环导致 TLE`	`套模板② → 根据大小决定 left++ / right--`
`反转字符串`	`左右相向交换`	`left < right`	`原地翻转完成，无返回值`	`忘记同步移动两根指针导致死循环或遗漏字符 `	`套模板② → 每次 swap 后同步 ++/--
`最长回文子串`	`左右从中心 outward`	`s==s while valid`	`最长回文子串本身 `	`不知道如何枚举奇偶中心 `	`外层遍历每个字符 → 调用 expand

---

• If you see “原地修改 / 删除”。首选快慢指针模板① .
• If you see “有序数组 + 查找 / 配对”，首选左右相向模板② .
• If you see “回文”或“中心 ”，使用从中心向外展开的左右策略③.
• If you see “子数组/子串 + 条件约束”，考虑滑动窗口.
• A good habit: 在每道题开始先写出「循环不变量」——这能方便你定位哪根指针对应哪个职责，从而避免跑出错误逻辑.
• You can practice by implementing four template functions once and n reuse m across dozens of LeetCode problems.
• The key is not memorizing each problem separately but mastering underlying pointer patterns.
• If any step feels confusing—especially order of ++/assignment—refer back to “痛点”提示，它们正是你最容易踩坑的地方！祝你玩转双指针 🎉.

---