双指针
这里介绍一种简单但非常有效的方式——双指针。所谓的双指针其实就是两个变量，不一定真的是指针。双指针思想简单好用，在处理数组、字符串等场景下很常见。看个例子，从下面序列中删除重复元素[1,2,2,2,3,3,3,5,5,7,8]，重复元素只保留一个。删除之后的结果应该为[1,2,3,5,7,8]。我们可以在删除第一个2时将将其后面的元素整体向前移动一次，删除第二个2时再将其后的元素整体向前移动一次，处理后面的3和5都一样的情况，这就导致我们需要执行5次大量移动才能完成，效率太低。如果使用双指针可以方便的解决这个问题，如图：
首先我们定义两个指针slow、fast。slow表示当前位置之前的元素都是不重复的，而fast则一直向后找，直到找到与slow位置不一样的 ，找到之后就将slow向后移动一个位置，并将arr[fast]复制给arr[slow]，之后fast继续向后找，循环执行。找完之后slow以及之前的元素就都是单一的了。这样就可以只用一轮移动解决问题。
上面这种一个在前一个在后的方式也称为快慢指针，有些场景需要从两端向中间走，这种就称为对撞型指针或者相向指针，很多题目也会用到，我们接下来会看到很多相关的算法题。 还有一种比较少见的背向型，就是从中间向两边走。这三种类型其实非常简单，看的只是两个指针是一起向前走（相亲相爱一起走），还是从两头向中间走（冲破千难万险来爱你），还是从中间向两头走（缘分已尽，就此拜拜）。
删除元素
原地移除所有数值等于 val 的元素
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
快慢指针
定义两个指针slow和fast，初始值都是0。
Slow之前的位置都是有效部分，fast表示当前要访问的元素。
这样遍历的时候，fast不断向后移动：
- 如果nums[fast]的值不为val，则将其移动到nums[slow++]处。
- 如果nums[fast]的值为val，则fast继续向前移动，slow先等待。
图示如下：
class Solution {
public int removeElement(int[] nums, int val) {
int slow = 0;
for(int fast = 0; fast< nums.length; fast++) {
if(nums[fast] != val) {
nums[slow++] = nums[fast];
}
}
return slow;
}
}
对撞双指针
对撞指针，有的地方叫做交换移除，核心思想是从右侧找到不是val的值来顶替左侧是val的值。什么意思呢？我们看图，我们以nums = [0,1,2,2,3,0,4,2], val = 2为例：
当left==right的时候，left以及左侧的就是删除掉2的所有元素了
public int removeElement(int[] nums, int val) {
int right = nums.length - 1;
int left = 0;
for(left = 0; left <= right; ) {
if((nums[left] == val) && (nums[right] != val)) {
int temp = nums[right];
nums[right] = nums[left];
nums[left] = temp;
}
if(nums[left] != val) left++;
if(nums[right] == val) right--;
}
return left;
}
删除有序数组中的重复项
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
本题使用双指针最方便，一个指针负责数组遍历，一个指向有效数组的最后一个位置。为了减少不必要的操作，我们做适当的调整，例如令slow=1，并且比较的对象换做nums[slow - 1]，代码如下：
public int removeDuplicates(int[] nums) {
//slow表示可以放入新元素的位置，索引为0的元素不用管
int slow = 1;
//循环起到了快指针的作用
for(int fast = 0;fast < nums.length; fast++) {
if(nums[fast] != nums[slow-1]) {
nums[slow] = nums[fast];
slow++;
}
}
return slow;
}
元素奇偶移动
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
维护两个指针 left=0 和 right=arr.length-1，left从0开始逐个检查每个位置是否为偶数，如果是则跳过，如果是奇数则停下来。然后right从右向左检查，如果是奇数则跳过偶数则停下来。然后交换array[left]和array[right]。之后再继续巡循环，直到left>=right。
public int[] sortArrayByParity(int[] nums) {
int left = 0, right = nums.length - 1;
while(left < right) {
if(nums[left] % 2 > nums[right] % 2) {
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
}
if(nums[left] % 2 == 0) left++;
if(nums[right] % 2 == 1) right--;
}
return nums;
}
数组轮转问题
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
这里介绍一种简单的方法：两轮翻转。
方法如下：
- 首先对整个数组实行翻转，例如 [1,2,3,4,5,6,7] 我们先将其整体翻转成[7,6,5,4,3,2,1]。
- 从 k 处分隔成左右两个部分，这里就是根据k将其分成两组 [7,6,5] 和[4,3,2,1]。
- 最后将两个再次翻转就得到[5,6,7] 和[1,2,3,4]，最终结果就是[5,6,7,1,2,3,4]
class Solution {
public void rotate(int[] nums, int k) {
k %= nums.length;
reverse(nums, 0, nums.length - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.length - 1);
}
public void reverse(int[] nums, int start, int end) {
while(start < end) {
int temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
start++;
end--;
}
}
}
数组的区间
力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台
使用双指针也可以非常方便的处理，慢指针指向每个区间的起始位置，快指针从慢指针位置开始向后遍历直到不满足连续递增（或快指针达到数组边界），则当前区间结束；然后将 slow指向更新为 fast + 1，作为下一个区间的开始位置，fast继续向后遍历找下一个区间的结束位置，如此循环，直到输入数组遍历完毕。
class Solution {
public List<String> summaryRanges(int[] nums) {
List<String> res = new ArrayList<>();
int slow = 0;
for(int fast = 0; fast < nums.length; fast++) {
if(fast + 1 == nums.length || nums[fast] + 1 != nums[fast + 1]) {
StringBuilder sb = new StringBuilder();
sb.append(nums[slow]);
if(slow != fast) {
sb.append("->").append(nums[fast]);
}
res.add(sb.toString());
slow = fast + 1;
}
}
return res;
}
}
字符串替换空格
这是剑指offer中的题目，出现频率也很高：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
首先要考虑用什么来存储字符串，如果是长度不可变的char数组，那么必须新申请一个更大的空间。如果使用长度可变的空间来管理原始数组，或者原始数组申请得足够大，这时候就可能要求你不能申请O(n)大小的空间，我们一个个看。
首先是如果长度不可变，我们必须新申请一个更大的空间，然后将原始数组中出现空格的位置直接替换成%20即可，代码如下：
public String replaceSpace(StringBuffer str) {
String res="";
for(int i=0;i<str.length();i++){
char c=str.charAt(i);
if(c==' ')
res += "%20";
else
res += c;
}
return res;
}
对于第二种情况，我们首先想到的是从头到尾遍历整个字符串，遇到空格的时候就将其后面的元素向后移动2个位置，但是这样的问题在前面说过会导致后面的元素大量移动，时间复杂度为O(n^2)，执行的时候非常容易超时。
比较好的方式是可以先遍历一次字符串，这样可以统计出字符串中空格的总数，由此计算出替换之后字符串的长度，每替换一个空格，长度增加2，即替换之后的字符串长度为:
新串的长度=原来的长度+2*空格数目
接下来从字符串的尾部开始复制和替换，用两个指针fast和slow分别指向原始字符串和新字符串的末尾，然后：slow不动，向前移动fast：
- 若指向的不是空格，则将其复制到slow位置，然后fast和slow同时向前一步；
- 若fast指向的是空格，则在slow位置插入一个%20，fast则只移动一步。
循环执行上面两步，便可以完成替换。详细过程如下：
实现代码如下：
public String replaceSpace(StringBuffer str) {
if (str == null)
return null;
int numOfblank = 0;//空格数量
int len = str.length();
for (int i = 0; i < len; i++) { //计算空格数量
if (str.charAt(i) == ' ')
numOfblank++;
}
str.setLength(len + 2 * numOfblank); //设置长度
int fast = len - 1; //两个指针
int slow = (len + 2 * numOfblank) - 1;
while (fast >= 0 && slow > fast) {
char c = str.charAt(fast);
if (c == ' ') {
fast--;
str.setCharAt(slow--, '0');
str.setCharAt(slow--, '2');
str.setCharAt(slow--, '%');
} else {
str.setCharAt(slow, c);
fast--;
slow--;
}
}
return str.toString();
}
