算法题：189. 轮转数组

题目：

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

提示：

• 1 <= nums.length <= 105
• -231 <= nums[i] <= 231 - 1
• 0 <= k <= 105

进阶：

• 尽可能想出更多的解决方案，至少有 三种 不同的方法可以解决这个问题。
• 你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

解题思路
        重要信息："modify nums in-place instead"，这条信息非常关键，指的是原位变化，那么什么是原位变化呢？python是怎么判断是在原位没有改变的呢？
        我们都知道，实际上我们的变量都是一个对象，这个对象拥有两个基本属性——value和id，value就是变量里存储的值，id就是变量的实际存储的内存地址，根据这个内存地址我们就可以找到对应的变量数据，这就是关键所在了：原位修改指的是运行完毕后，nums的id地址不变，也就是说，一切会导致nums最后id改变的实现方式都是错误的，因为leetcode编译器会直接去读取原始的内存地址中存储的数据，如果你新建了nums变量，在新的id地址上实现了效果，但是很不幸，没用，因为原来id地址上的内容完全没改变，所以你的结果还是原来的模样，未曾改变半分，所以这也是很多人明明print(nums)看到了数据改变，但是编译器显示nums未曾改变的原因。

方法一：使用python中list的内置方法完成

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        # nums.pop()是弹出并原地删除list中的最后一位数据
        # nums.insert(index,num)是表示在指定索引位置插入数据，如果索引长度超过list长度，会直接插入到最后一位
        for i in range(k):
            nums.insert(0,nums.pop())

时间复杂度：O(n × k)

1. nums.pop()：

   • 每次弹出列表最后一个元素，时间复杂度为 O(1)（因为直接访问末尾）。

2. nums.insert(0, x)：

   • 每次在列表开头插入元素，需要将列表中所有元素向后移动一位，时间复杂度为 O(n)（n 是列表长度）。

3. 循环 k 次：

   • 总时间复杂度为 O(k × n)。

   • 当 k 接近 n 时，最坏情况为 O(n²)（例如 k = n）。

空间复杂度：O(1)

• 仅使用了常数级别的额外空间（如变量 i 和临时存储弹出的元素），没有依赖输入规模的额外数据结构，因此空间复杂度为 O(1)（原地修改）。

方法二：取模 + 切片

class Solution:
        """
        Do not return anything, modify nums in-place instead.
        """
    def rotate(self,nums:list[int],k:int) -> None:
        k = k % len(nums)
        nums[:] = nums[-k:] + nums[:-k]

1. 为什么需要 k % len(nums)？

• 问题背景：
  当旋转次数 k 等于数组长度 n 时，旋转之后其实列表是没有变化的。当旋转次数 k 大于数组长度 n 时，旋转 k 次和旋转 k % n 次的效果 完全相同。

  • 例如：数组 [1, 2, 3]，旋转 4 次（4 % 3 = 1）等价于旋转 1 次。

  • 旋转 n 次等于没旋转（数组恢复原状）。

• 数学原理：
  取模运算将 k 映射到 [0, n-1] 的范围内，避免无效操作。

• 时间 O(n)，但需临时存储切片（空间 O(n)）。

方法三：三次反转（严格 O(1) 空间）

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        def reverse(l,r):
            while l<r:
                nums[l] ,nums[r] = nums[r], nums[l]
                l+=1
                r-=1
        
        n=len(nums)
        k=k%n
        reverse(0,n-1) # 整体反转
        reverse(0,k-1) # 前半部分分反转
        reverse(k,n-1) # 后半部分反转
        

• 时间 O(n)，空间 O(1)（完全原地操作）