LeetCode.双指针(一)
例题一
一、题目
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:输入: nums = [0]
输出: [0]
提示:
1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1作者：LeetCode
链接：https://leetcode.cn/leetbook/read/all-about-array/x9rh8e/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
二、代码
思路1：类似冒泡排序
1.遍历数组
2.遇到0则记录该元素的索引，开始把0与下一个元素交换
3.每次循环把一个0放到数组末尾
4.每次处理一个0后，数组的顺序就有变化，不能延用原来的顺序
void moveZeroes(int* nums, int numsSize){
/*
思路1：类似冒泡排序
1.遍历数组
2.遇到0则记录该元素的索引，开始把0与下一个元素交换
3.每次循环把一个0放到数组末尾
4.每次处理一个0后，数组的顺序就有变化，不能延用原来的顺序
*/
int count = 0;//已处理好的0的个数
for(int i = 0; i < numsSize; i++){
if(nums[i] == 0){
for(int j = i; j < numsSize - 1 - count; j++){
nums[j] = nums[j+1];
nums[j+1] = 0;
}
count++;
i--;
}
}
}时间复杂度：O(n^2)
空间复杂度：O(n)
思路2：
转换思路，不要移动0，而是把非零的数字向前移动，剩余空位的补0即可。
方法：
设置两个指针i和j，i用来遍历数组，找0元素，j用来指向0元素位置。
当指针i每遇到一个非0，就与把值赋给j指针，同时j移向下一个位置；
当指针i每遇到一个0，则不需要赋值给指针j，同时j也不需要后移。
当指针i遍历结束，则指针j后面所有位置补0
void moveZeroes(int* nums, int numsSize){
int j = 0;
for(int i = 0; i < numsSize; i++){
if(nums[i] != 0){
nums[j] = nums[i];
j++;
}
}
for(;j < numsSize; j++){
nums[j] = 0;
}
}时间复杂度：O(n)
空间复杂度：O(n)
例题二
一、题目
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2：输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100作者：LeetCode
链接：https://leetcode.cn/leetbook/read/all-about-array/x9p1iv/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
二、代码
删除指定的值k的元素并返回剩余元素长度，即把指定值k的元素移至数组末端，然后返回剩余元素的长度。本题的思想与例一类似，不过多了一个记录数组长度。
思路：双指针
1.设置两个指针i，j
2.i用来遍历数组，j用来指向新数组的元素
3.当i遇到非k(被删除的元素值为k)时，把就数组的元素赋值给新的数组nums[j] = num[i]，同时j指向后一个元素。
4.当遇到k时，则不需要赋值给新的数组，j不动
5.数组遍历结束，新数组即为删除k后的数组，而 j+1 即为新数组长度。
6.以上所述的新旧数组可在同一个数组中进行
int removeElement(int* nums, int numsSize, int val){
// 直接遍历一遍数组，遇到val就删了，同时记录nums的变化
//类似移动0
//双指针，一个遍历，一个记录上一个可以填充的位置
int j = -1;//j = 0
for(int i = 0; i < numsSize; i++){
if(nums[i] != val){
//两种思路：一种是先赋值然后移动j,
//另一种是先移动j，然后赋值，
//主要区别是当前j指向的是当前要被赋值的对象还是上一个
// nums[j] = nums[i];
// j++;
j++;
nums[j] = nums[i];
}
}
return j + 1;
}时间复杂度：O(n)
空间复杂度：O(1)
例题三
一、题目
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。
判题标准:系统会用下面的代码来测试你的题解:
int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案int k = removeDuplicates(nums); // 调用
assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
assert nums[i] == expectedNums[i];
}
如果所有断言都通过，那么您的题解将被 通过。示例 1：
输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2：输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
提示：
1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按 升序 排列作者：LeetCode
链接：https://leetcode.cn/leetbook/read/all-about-array/x9a60t/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
二、代码
思路：删除重复的元素，即需要判断当前元素是否已经出现过，需要两个指针，一个遍历，一个指向之前的元素。
1.i指针用来遍历，j指针指向新的数组
2.j指向第一个元素，i从第二个元素开始遍历，每次判断nums[i] == nums[j]，如果相等则说明已经出现过该元素，i后移，j不动
3.当nums[i] != nums[j]时，说明，i指向的是一个新的元素，把新元素添加到数组中，j++
int removeDuplicates(int* nums, int numsSize){
int j = 0;
for(int i = 1; i < numsSize; i++){
if(nums[i] != nums[j]){
nums[++j] = nums[i];
}
}
return j + 1;
}时间复杂度：O(n)
空间复杂度：O(1)
例题四
一、题目
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
说明：
为什么返回数值是整数，但输出的答案是数组呢？
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
示例 1：
输入：nums = [1,1,1,2,2,3]
输出：5, nums = [1,1,2,2,3]
解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。
示例 2：输入：nums = [0,0,1,1,1,1,2,3,3]
输出：7, nums = [0,0,1,1,2,3,3]
解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。
提示：
1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列作者：LeetCode
链接：https://leetcode.cn/leetbook/read/all-about-array/x9nivs/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
二、代码
本题在上一个题目上做了延申，上一个题目可以看作最多保留1个相同的元素，而本体则是最多保留两个相同的元素。
思路：依旧是双指针
1.i遍历数组，j指向新数组中的元素
2.设置一个count来记录当前值出现的个数
3.当count <=1 时，保留该元素
int removeDuplicates(int* nums, int numsSize){
int j = 0;
int count = 1;
for(int i = 1; i < numsSize; i++){
if(nums[i] == nums[j]){
count++;
}else{
count = 1;
}
if(count <= 2){
nums[++j] = nums[i];
}
}
return j + 1;
}时间复杂度：O(n)
空间复杂度：O(1)
思考题：
对于例题三和例题四，我们再做一个延展，若是最多保留3个？4个？5个？重复的元素呢？即最多保留k个重复的元素，该如何解答？
思路1：我们发现保留k个元素，即用count记录重复元素的个数，若是count <= k,则保留该元素
代码：
int removeDuplicates(int* nums, int numsSize){
int k = 3;//k为最多保留重复元素的个数
int j = 0;
int count = 1;
for(int i = 1; i < numsSize; i++){
if(nums[i] == nums[j]){
count++;
}else{
count = 1;
}
if(count <= k){
nums[++j] = nums[i];
}
}
return j + 1;
}思路2：我们需要保留k个元素，就需要在遍历数组的同时知道，已经重复了几个，思路1是采用的count来记录重复的个数。但是我们可以发现，这些元素的排列是有规则的，无论保留几个，这些元素都是升序排序的，这就保证了，相同的元素一定是聚在一起的。
如此，当k = 2时,当判断是否需要保留i指向的元素时，只需要判断nums[i-2] == nums[i]是否相等即可，若相等，则说明有两个重复的了，则不需要保留。若不相等，则说明没有两个重复的，最多只有一个，则可以保留当前元素。
同理，当k = 3 时，nums[i-3] == nums[i] ;
当k = 4 时，nums[i-4] == nums[i]；
。。。。
代码(最多保留k个重复的元素的通解):
int removeDuplicates(int* nums, int numsSize){
int k = 2;
int j = k;//直接保留前k个元素,j指向下一个空位
for(int i = k; i < numsSize; i++ ){//从第k+1个元素开始判断
if(nums[i] == nums[j - k]){//判断当前元素与最后保留的k个是否相同
continue;
}else{//不相同则保留
nums[j++] = nums[i];
}
}
return numsSize <= k ? numsSize : j;//若数组长度小于k则直接保留
}注意：由于是在同一个数组中操作，在j修改数组时，会导致在判断nums[i] == nums[i-k]的判断有误，所以可以做一些调整，判断nums[i] 与最近保留的k个元素是否相同。
时间复杂度：O(n)
空间复杂度：O(1)
三、总结
以上几题均采用的是双指针操作，而且都是一个指针在前，一个指针在后的方式，准确一点，是一个用于遍历，一个用于修改新的数组。这样解决问题，均是在同一个数组中操作，使得空间复杂度更低。
但是在分析思考的过程中，我们可以采用两个不同数组，更清晰，有利于思考！！！