力扣189:轮转数组

189. 轮转数组 - 力扣(LeetCode)

题目描述:给你一个数组,将数组中的元素向右轮转k个位置,其中k是非负数。

 为什么会想到取余数?

对于循环数组而言,移动到数组末尾之后要想继续从头开始移动,其实就是移动余数步数。

思路1:循环数组取余法

额外开辟一个数组,将原数组移动后的元素直接放入新开辟的数组中,其中,涉及到数组的取模运算。

  • 当i+k<n,直接放入i+k的位置即可(i+k%n);
  • 当i+k>=n,此时说明已经走到数组的末尾,需要从数组的开头进行移动(i+k%n)。

 代码实现:

//循环数组取余法
    public void rotate(int[] nums,int k){
        //开辟一个和原数组大小相同的新数组
        int[] temp=new int[nums.length];
        //将原数组元素向右移动k步之后置入temp数组中
        for(int i=0;i<nums.length;i++){
            temp[(i+k)%nums.length]=nums[i];
        }
        //此时temp数组中存储了移动后的元素,写回nums数组
        for (int i = 0; i <nums.length ; i++) {
            nums[i]=temp[i];
        }
    }

思路2:反转数组法

空间复杂度为O(1)的原地算法。

整体反转的目的是将nums2数组调整到nums1的前面;

子数组的反转是为了还原原来元素的相对顺序。

代码实现:

//2.反转数组法
    public void rotate(int[] nums,int k){
        //k有可能超过数组长度,将多余的步数取余处理掉
        k%=nums.length;
        //1.整体数组反转,将需要移动到前面的元素通过整体反转nums2移动到nums1的前面
        reverse(nums,0,nums.length-1);
        //2.子数组分别反转,负负得正,将子数组内部的元素还原为反转前的元素状态
        reverse(nums,0,k-1);
        reverse(nums,k,nums.length-1);
    }
    public void reverse(int[] nums,int left,int right){
        while(left<right){
            int temp=nums[left];
            nums[left]=nums[right];
            nums[right]=temp;
            left++;
            right--;
        }
    }

在解决 LeetCode 上的轮转数组问题时,需要考虑多个关键点,包括如何处理边界情况、如何避免额外的空间使用以及如何高效地进行元素移动。以下是几种常见的解法: ### 解法一:使用临时数组 这种方法的基本思路是将数组中最后 `k` 个元素存储到一个临时数组中,然后将原数组中的前面部分向右移动 `k` 个位置,最后将临时数组中的元素放回到原数组的前面。 ```java class Solution { public void rotate(int[] nums, int k) { int length = nums.length; k = k % length; // 处理k大于数组长度的情况 int[] temp = new int[k]; // 将最后k个元素存储到临时数组中 for (int i = 0; i < k; i++) { temp[i] = nums[length - k + i]; } // 将原数组前面的元素向右移动k个位置 for (int i = length - 1; i >= k; i--) { nums[i] = nums[i - k]; } // 将临时数组中的元素放到原数组的前面 for (int i = 0; i < k; i++) { nums[i] = temp[i]; } } } ``` 这种方法的时间复杂度为 O(n),空间复杂度为 O(k)[^2]。 --- ### 解法二:三次反转 这种解法不需要额外的空间,而是通过三次反转操作来实现数组轮转。具体步骤如下: 1. 反转数组的后 `k` 个元素。 2. 反转数组的前 `n-k` 个元素。 3. 最后反转整个数组。 ```c void reverse(int* nums, int left, int right) { while (left < right) { int tmp = nums[left]; nums[left] = nums[right]; nums[right] = tmp; left++; right--; } } void rotate(int* nums, int numsSize, int k) { if (k > numsSize) { k %= numsSize; } reverse(nums, numsSize - k, numsSize - 1); // 右边倒置 reverse(nums, 0, numsSize - k - 1); // 左边倒置 reverse(nums, 0, numsSize - 1); // 整体倒置 } ``` 这种方法的时间复杂度为 O(n),空间复杂度为 O(1)[^3]。 --- ### 解法三:直接计算新索引 这种方法利用了模运算来计算每个元素的新位置,并将其复制到新的数组中。之后再将新数组的内容复制回原数组。 ```java public class Solution { public void rotate(int[] nums, int k) { int length = nums.length; int[] temp = new int[length]; // 将原数组的元素放到新数组中对应的位置 for (int i = 0; i < length; i++) { temp[(i + k) % length] = nums[i]; } // 将temp数组的内容复制回nums数组 for (int i = 0; i < length; i++) { nums[i] = temp[i]; } } } ``` 这种方法的时间复杂度为 O(n),空间复杂度为 O(n)[^4]。 --- ### 解法四:数组切片(Python) 在 Python 中,可以利用数组切片来实现轮转数组的操作。然而需要注意的是,在函数内部修改数组时,必须直接对原数组进行操作,而不是创建一个新的数组引用。 ```python class Solution: def rotate(self, nums: List[int], k: int) -> None: n = len(nums) k = k % n # 处理k大于数组长度的情况 nums[:] = nums[-k:] + nums[:-k] ``` 这种方法的时间复杂度为 O(n),空间复杂度为 O(n)[^1]。 --- ### 相关问题 1. 如何在不使用额外空间的情况下实现轮转数组? 2. 为什么在轮转数组问题中需要对 `k` 进行取模操作? 3. 在使用数组切片方法时,为什么不能直接赋值给 `nums` 而要使用 `nums[:]`? 4. 三次反转法的具体实现原理是什么? 5. 使用临时数组的方法和直接计算新索引的方法有什么区别?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值