一、什么是双指针算法？
严格的来说，双指针只能说是是算法中的一种技巧。
双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢指针）或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。
二、双指针算法的适用范围
常用在数组遍历中，我们使用两个指针进行操作，遍历完整个数组来实现我们的目的。一般能用双指针算法解决的问题，都可以用暴力解法解决，常用于单调场景。所以双指针问题基本有以下几个细节：
1、注意双指针的初始位置。
2、注意双指针的移动方法。
3、注意遍历的结束条件。三、顺序双指针和对撞双指针
顺序双指针指的是2个指针的遍历方向相同，常用于数组的拼接等场景。
对撞双指针是指2个指针从两头向中间进行数组遍历，快速排序就是典型的双指针问题。
代码实现：
我们假设数组名字为 nums，数组长度为 n，数组首元素对应的位置为 0，尾元素对应的位置为 n-1
顺序双指针的实现过程就是每次把数组的首指针++ 或 尾指针- -，例如Leecode88.合并2个数组，https://leetcode-cn.com/problems/merge-sorted-array/，分别同时从头遍历2个数组或从尾遍历2个数组，结束条件为2个指针同时越界即可。
这里贴出双指针头遍历和尾遍历的代码实现：
/**
* 0 1 2 3 4 5
* nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
* 每次从两个数组头部取出比较小的数字放到结果中
*/
public void merge0(int[] nums1, int m, int[] nums2, int n) {
int p1 = 0, p2 = 0;
int[] sorted = new int[m + n];
int cur;
// 双指针结束条件
while (p1 < m || p2 < n) {
if (p1 == m) {
// 端口位置特殊判断, p1已经遍历完就继续遍历p2
cur = nums2[p2++];
} else if (p2 == n) {
cur = nums1[p1++];
} else if (nums1[p1] < nums2[p2]) {
// p1小,p1入队,p1++
cur = nums1[p1++];
} else {
// p2小,p2入队,p2++
cur = nums2[p2++];
}
sorted[p1 + p2 - 1] = cur;
}
for (int i = 0; i < m + n; i++) {
nums1[i] = sorted[i];
}
}
/**
* 0 1 2 3 4 5
* nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
* 每次从两个数组尾部取出比较大的数字放到结果中
*/
public static void merge(int[] nums1, int m, int[] nums2, int n) {
int p1 = m - 1;
int p2 = n - 1;
int cur;
while (p1 > 0 || p2 > 0) {
if (p1 == 0) {
cur = nums2[p2--];
} else if (p2 == 0) {
cur = nums1[p1--];
} else if (nums1[p1] > nums2[p2]) {
cur = nums1[p1--];
} else {
cur = nums2[p2--];
}
nums1[p1 + p2 + 2] = cur;
}
}对撞双指针我们一般需要设置2个指针分别指向最数组左端点和右端点
左指针（left)一般指向数组的第一个元素。即 left = 0。
右指针（right)一般指向数组的第一个元素。即 right = n-1。
指针移动方法：
左指针(left）向右边👉移动，一般每次移动一个位置，即 left++。
右指针(right）向左边👈移动，一般每次移动一个位置，即 right–。
结束条件：
左指针（left）位置和右指针（right）位置逆序。
从上面的描述可知，开始的时候，right >= left。因此结束的条件就是 right < left。
伪代码
function fn(int list[], int len) {
int left = 0;
int right = len - 1;
//遍历数组
while (left <= right) {
left++;
// 一些条件判断 和处理
... ...
right--;
}
}具体应用的实现：快速排序，可参考博主博文：
四、例题
我们使用 LeetCode 881 救生艇为例，https://leetcode-cn.com/problems/boats-to-save-people/
解题大致思路为：
1、排序。
2、初始化双指针。
3、遍历。每次都用一个最重的和一个最轻的进行配对，如果二人重量小于 Limit，则此时的最轻的上船，left++。不管最轻的是否上船，最重的都要上船，right–。并且所需船数量加一，num++。
AC 参考代码
class Solution {
public:
int numRescueBoats(vector<int>& people, int limit) {
sort(people.begin(), people.end());//排序
int ans = 0;//答案
int left = 0;//左指针
int right = people.size() - 1;//右指针
while (left<=right) {
if (people[left]+people[right]<=limit) {
left++;
}
right--;
ans++;
}
return ans;
}
};五、快慢指针
快慢指针是两个指针从同一侧开始遍历数组，将这两个指针分别定义为快指针（fast）和慢指针（slow），两个指针以不同的策略移动，直到两个指针的值相等（或其他特殊条件）为止，如快指针（fast）每次增长两个，慢指针（slow）每次增长一个。
一般来说，快慢指针常用于判断链表等数据结构中是否有环。比如下图所示的一个链表。
图解
下面我们用一系列图像说明，快慢指针查找环的过程。
初始位置
如下图所示，慢指针（slow）和快指针（fast）同时指向第一个元素。
移动一次
慢指针（slow）向后移动一个位置，快指针（fast）向后移动两个位置，如下图所示。
移动两次
慢指针（slow）向后移动一个位置，快指针（fast）向后移动两个位置，如下图所示。
移动三次
慢指针（slow）向后移动一个位置，快指针（fast）向后移动两个位置，如下图所示。我们发现慢指针（slow）和快指针（fast）重合，说明有环。
代码细节
指针初始位置
慢指针（slow）一般指向数组的第一个元素。即 slow = 0。
快指针（fast）一般指向数组的第一个元素。即 fast = 1。
指针移动方法
慢指针（slow）向右边👉移动，一般每次移动一个位置，即 slow++。
快指针（fast）向右边👉移动，一般每次移动两个个位置，即 fast += 2。
结束条件
慢指针（slow）位置和快指针（fast）位置重合；快指针（fast）达到数组的最后一个元素。
特别注意，要判断达到最后一个元素。否则会出现死循环。
伪代码
注意：伪代码只是表示一种结构。
function fn(LinkList *list, int len) {
int slow = 0;
int fast = 1;
//遍历数组
while (slow != fast) {
slow++;
// 一些条件判断 和处理
... ...
fast+=2;
}
}例题
我们使用 LeetCode 141 环形链表为例，https://leetcode-cn.com/problems/linked-list-cycle
解题大致思路为：
1、排序。
2、初始化双指针。
3、遍历。
AC 参考代码
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode *slow = head;//慢指针
ListNode *fast = head;//快指针
while (NULL!=fast && NULL!=fast->next && NULL!=fast->next->next) {
//修改位置
slow = slow->next;
fast = fast->next->next;
//判断有环
if (slow==fast) {
return true;
}
}
//无环
return false;
}
};部分例题和快慢指针引自：
