LeetCode.双指针(一)

xiaoyan_lu

已于 2023-08-04 17:41:16 修改

阅读量76

点赞数

分类专栏： LeetCode 文章标签：算法 leetcode

于 2023-06-26 23:31:50 首次发布

本文链接：https://blog.csdn.net/m0_62780794/article/details/131407194

版权

LeetCode 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

例题一

一、题目

给定一个数组 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)