【Hot100算法刷题集】双指针-01-移动零（含置零思路、移动思路、偏移量思路、冒泡法）

最新推荐文章于 2024-09-26 00:03:11 发布

Jammingpro

最新推荐文章于 2024-09-26 00:03:11 发布

阅读量1.1k

点赞数 29

分类专栏： hot100算法专题文章标签：算法力扣 leetcode c++

本文链接：https://blog.csdn.net/m0_66926829/article/details/141978937

版权

hot100算法专题专栏收录该内容

5 篇文章 0 订阅

订阅专栏

在这里插入图片描述

🏠关于专栏：专栏用于记录LeetCode中Hot100专题的所有题目
🎯每日努力一点点，技术变化看得见

题目转载

题目描述

🔒link->题目跳转链接
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意，必须在不复制数组的情况下原地对数组进行操作。

题目示例

示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:
输入: nums = [0]
输出: [0]

题目提示

● $1$ <= nums.length <= $10^4$
● $2^{31}$ <= nums[i] <= $2^{31} - 1$

解题思路及代码

非移动（置零）思路&&双指针解法

题目的意思是，将所有的零移动到整个数组的最后面。这里先介绍非移动的解题逻辑：使用一个下标dst保存当前最后一个非零元素的下一个位置的下标，当遍历元素nums[cur]时，如果nums[cur]非零，则执行nums[++dst]=nums[cur]操作；cur遍历完nums后，借助dst将dst之后的元素置零。

这里就是将非零元素都保存到nums数组的前面，再将剩下的位置置零。
在这里插入图片描述

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int dst = 0;
        for(int cur = 0; cur < nums.size(); cur++)
        {
            if(nums[cur] != 0) nums[dst++] = nums[cur];
        }
        for(; dst < nums.size(); dst++)
        {
            nums[dst] = 0;
        }
    }
};

移动思路&&双指针解法

使用dst记录最后一个非零元素的下标，cur记录当前遍历到的元素的下标。若nums[cur]==0，则不需要进行任何操作，若nums[cur]!=0，则需要swap(nums[++dst], cur)。这里的思路是，如果遇到的是非零元素，则交换到0到dst之间，那么(dst,cur]之间就都是0。下方两张图是对该思路的演示，使用的是示例1：[0, 1, 0, 3, 12]。
在这里插入图片描述

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int dst = -1;
        for(int cur = 0; cur < nums.size(); cur++)
        {
            if(nums[cur] != 0) swap(nums[++dst], nums[cur]);
        }
    }
};

偏移量法

在上面一个解法中，(dst, cur]之间都是0，那么我们可以定义一个变量offset记录0的个数。当遍历到nums[cur]==0时，则++offset；否则执行swap(nums[cur], nums[offset])的操作。这个思路用示例解释更为清晰，下方图是对示例1：[0, 1, 0, 3, 12]执行该方法的演示。
在这里插入图片描述
这个方法的最主要的就是这个offset变量，它记录了0的个数，因而cur-offset就能找到距离cur最远的一个0，从而进行交换时，就能将非0元素换到最左0元素的位置上。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int offset = 0;
        for(int cur = 0; cur < nums.size(); cur++)
        {
            if(nums[cur] == 0)
            {
                ++offset;
            }
            else
            {
                swap(nums[cur], nums[cur - offset]);
            }
        }
    }
};

冒泡法

上述算法的时间复杂度均为 $O (N)$ ，而这里有个效率低下，但值得一探究竟的算法——冒泡法。这个思路就是冒泡排序，如果当前元素是0，通过不断将0元素交换到最后。每一次执行内层循环的目的就是为了将一个0元素交换到最后。但这个算法效率过低，效率为 $O(N^2)$ ，建议作为了解即可。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        for(int i = 0; i < nums.size() - 1; i++)
        {
            for(int j = 0; j < nums.size() -i - 1; j++)
            {
                if(nums[j] == 0)
                {
                    swap(nums[j], nums[j + 1]);
                }
            }
        }
    }
};