leetcode轮转数组

​​​​

1.暴力破解法

因为nums.length为10的五次方 时间复杂度为O(n^2) 已经到了很大的程度 所以最后的数据大概率会超时

class Solution {
    public void rotate(int[] nums, int k) {
        for(int t =0;t < k ;t++){
            int temp = nums[nums.length-1];
        	for(int i =nums.length - 1;i >0;i--){
            	nums[i] = nums[i-1];
        	}
        	nums[0] = temp;
    	}
    }
}

双层循环去模拟轮转数组的过程

不出所料 在最后一组用例超时

2.创建临时数组

优化算法 因为本身数组翻转会导致数据丢失 所以我想到再创建一个额外的数组去存储这个数据

1. 初始化指针和临时数组。
2. 对旋转步数 k 进行取模操作，以避免不必要的旋转次数。
3. 遍历原数组，根据旋转后的位置将元素放入临时数组中。
4. 将临时数组中的元素复制回原数组。

class Solution {
    public void rotate(int[] nums, int k) {
        // 初始化指针，并检查数组长度是否为 0
        int p = 0; // 用于遍历数组的指针
        int maxp = nums.length - 1; // 数组的最大索引
        if (maxp == 0) { // 如果数组长度为 1
            return; // 直接返回，无需旋转
        }
        // 创建一个临时数组用于存储旋转后的结果
        int[] temp = new int[maxp + 1];
        // 对 k 进行取模，避免不必要的旋转次数
        k = k % nums.length;
        // 遍历原数组
        for (int i = 0; i <= maxp; i++) {
            // 判断旋转后的位置是否越界
            if (i + k > maxp) {
                // 若越界，则将当前元素放置到 temp 数组的正确位置
                temp[i + k - maxp - 1] = nums[i];
            } else {
                // 若不越界，则将当前元素放置到 temp 数组的正确位置
                temp[i + k] = nums[i];
            }
        }
        // 将 temp 数组中的元素复制回原数组
        for (int i = 0; i <= maxp; i++) {
            nums[i] = temp[i];
        }
    }
}

注意点

1.当数组元素只有一位的时候，不能进入下面的代码块，因为产生边界问题，
2.输入k的值要去取余的操作去得到移多少步
3.数组好像不能直接像变量覆盖，所以用for循环去覆盖

感觉还能优化

3.三次翻转数组

首先，对旋转步数 k 进行取模操作，以确保 k 不会超出数组的长度，因为旋转 n 个位置（n 为数组长度）等效于不旋转。
然后，可以使用三次数组翻转来实现旋转操作：
第一次翻转：将整个数组翻转。
第二次翻转：将前 k 个元素翻转。
第三次翻转：将剩余的元素翻转。

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k %= n; // 对 k 进行取模操作

        // 第一次翻转：将整个数组翻转
        reverse(nums, 0, n - 1);
        // 第二次翻转：将前 k 个元素翻转
        reverse(nums, 0, k - 1);
        // 第三次翻转：将剩余的元素翻转
        reverse(nums, k, n - 1);
    }

    // 辅助函数：翻转数组指定范围内的元素
    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }
}

思路就好在把一次翻转的过程拆分成三次 这样就避免的元素被覆盖丢失 不需要额外创建数组