什么是「循环不变量」？

liweiwei1419
3,314 阅读2分钟

知识点总结：

  • 「循环不变量」就是 在循环的过程中保持不变的性质；
  • 保持什么不变，是我们根据任务和目的而自行定义的，不同的循环不变量对应了不同的算法；
  • 我习惯把循环不变量作为注释写在代码中，可以帮助我们理清代码的思路。

例 1：「力扣」第 26 题：删除排序数组中的重复项（简单）

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

示例 1：

给定数组 nums = [1,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。

你不需要考虑数组中超出新长度后面的元素。
  • 重要条件：排序数组；
  • 要求：重复元素最多只能出现一次。
  • 思路：
    • 使用循环变量 i 遍历输入数组一次；
    • 使用 j 在输入数组上进行覆盖。注意：下标之差为 1 的元素的数值不可以相等。
  • 总结：用 i 遍历，j 赋值，j - 1 进行比较。

参考代码 1：

public class Solution {

    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        if (len < 2) {
            return len;
        }

        // 循环不变量：nums[0..j) 没有重复元素
        // j 指向了下一个要赋值的元素
        int j = 1;
        for (int i = 1; i < len; i++) {
            if (nums[i] != nums[j - 1]) {
                nums[j] = nums[i];
                j++;
            }
        }
        return j;
    }
}

参考代码 2：

public class Solution {

    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        if (len < 2) {
            return len;
        }
        // 循环不变量：nums[0..j] 没有重复元素，j 是刚刚赋值完的元素的下标
        int j = 0;
        for (int i = 1; i < len; i++) {
            if (nums[i] != nums[j]) {
                j++;
                nums[j] = nums[i];
            }
        }
        return j + 1;
    }
}

例 2：「力扣」第 283 题：移动零（简单）

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例：

输入: [0,1,0,3,12]

输出: [1,3,12,0,0]

说明：

  1. 必须在原数组上操作，不能拷贝额外的数组。
  2. 尽量减少操作次数。

参考代码 1：

public class Solution {

    public void moveZeroes(int[] nums) {
        int len = nums.length;
        if (len < 2) {
            return;
        }

        // nums[0..j) != 0
        // nums[j..i) == 0
        int j = 0;
        for (int i = 0; i < len; i++) {
            if (nums[i] != 0) {
                nums[j] = nums[i];
                j++;
            }
        }

        for (int i = j; i < len; i++) {
            nums[i] = 0;
        }
    }
}

class Solution:

    # 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
    # 快速排序的方法，最简单，最直接

    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """

        # 循环不变量保持 [0, j） 保持都非 0，
        # [j, len-1] 为 0
        # j 表示下一个非零元素的位置
        j = 0

        for i in range(len(nums)):
            # 遇到 0 放过，不是 0 的交换到前面去
            if nums[i] != 0:
                nums[j], nums[i] = nums[i], nums[j]
                j += 1

参考代码 2：

public class Solution {

    public void moveZeroes(int[] nums) {
        int len = nums.length;
        if (len < 2) {
            return;
        }

        // 循环不变量：nums[0..j] 非零，且保持顺序，j 指向马上要赋值的元素
        // nums(j..i) = 0
        int j = -1;
        for (int i = 0; i < len; i++) {
            if (nums[i] != 0) {
                j++;
                nums[j] = nums[i];
            }
        }

        for (int i = j + 1; i < len; i++) {
            nums[i] = 0;
        }
    }
}

例 3：「力扣」第 27 题：移动元素（简单）

给定一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地修改输入数组 并在使用 O(1)O(1) 额外空间的条件下完成。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3, 2, 2, 3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0, 1, 2, 2, 3, 0, 4, 2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。

说明：

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以 “引用” 方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下：

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

思路：设置一个指针 j，遍历过程中遇到要删除的元素，跳到下一个，遇到保留元素，j 位置赋值，并且 j 索引 + 1。

参考代码 1：

public class Solution {

    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        if (len == 0) {
            return 0;
        }

        // nums[0..j) 不包含 val，j 指向了下一个要赋值的元素的位置
        // 等于 val 的时候跳过，不等于 val 的时候赋值
        int j = 0;
        for (int i = 0; i < len; i++) {
            if (nums[i] != val) {
                nums[j] = nums[i];
                j++;
            }
        }
        return j;
    }
}

class Solution:
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """

        size = len(nums)
        if size == 0:
            return 0

        j = 0
        for i in range(size):
            if nums[i] != val:
                nums[j] = nums[i]
                j += 1
        return j

参考代码 2：

public class Solution {

    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        if (len == 0) {
            return 0;
        }

        // nums[0..j] 不包含 val，j 指向了刚刚赋值完的元素的值
        // 等于 val 的时候跳过
        // 不等于 val 的时候赋值
        int j = -1;
        for (int i = 0; i < len; i++) {
            if (nums[i] != val) {
                j++;
                nums[j] = nums[i];
            }
        }
        return j + 1;
    }
}

例 4：「力扣」第 80 题：删除排序数组中的重复项 II（中等）

给定一个增序排列数组 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 。 你不需要考虑数组中超出新长度后面的元素。

提示：

  • 0 <= nums.length <= 3 * 104
  • -10^4 <= nums[i] <= 10^4
  • nums 按递增顺序排列

关键的地方：下标的差为 2 的两个数不能一样。即将赋值的元素的值只要和它左边的左边的元素的值不一样，就可以赋值。

循环不变量：nums[0..j) 是有序数组，并且相同的元素最多出现 22 次，j 指向了下一个要赋值的元素。

参考代码 1：

public class Solution {

    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        if (len < 3) {
            return len;
        }

        // 循环不变量：nums[0..j) 是最终返回的数组
        // 初始化的时候，前 2 位有效
        // [0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4]
        //           j
        //              i
        // j 指向下一个要填写的元素
        int j = 2;
        for (int i = 2; i < len; i++) {
            if (nums[i] != nums[j - 2]) {
                nums[j] = nums[i];
                j++;
            }
        }
        return j;
    }
}

from typing import List


class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        size = len(nums)
        if size <= 2:
            return size
        # counter 表示下一个要覆盖的下标
        counter = 2
        # 下标为 0 和 1 的数一定会被保留，因此遍历从下标 2 开始
        for i in range(2, size):
            if nums[i] != nums[counter - 2]:
                nums[counter] = nums[i]
                counter += 1
        return counter

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        l = len(nums)
        if l <= 2:
            return l
        counter = 2
        for i in range(2, l):
            if nums[i] != nums[counter - 2]:
                nums[counter] = nums[i]
                counter += 1
        return counter

参考代码 2：

public class Solution {

    public int removeDuplicates(int[] nums) {
        int len = nums.length;
        if (len < 3) {
            return len;
        }
        
        // 循环不变量：nums[0..j] j 指向了已经赋值的最后一个元素
        int j = 1;
        for (int i = 2; i < len; i++) {
            if (nums[i] != nums[j - 1]) {
                j++;
                nums[j] = nums[i];
            }
        }
        return j + 1;
    }
}

复杂度分析：

  • 时间复杂度：O(N)O(N)，我们遍历每个数组元素一次；
  • 空间复杂度：O(1)O(1)。
avatar
文章
阅读
粉丝