letcode

letcode

给你一个数组，将数组中的元素向右轮转 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]

我的方法:
时间复杂度为n*n

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

改进方法一
这个是领扣的的解法一般，但是对下标的 *** 作很灵巧

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] = nums[i];
        }
        //然后在把临时数组的值重新放到原数组，并且往右移动k位
        for (int i = 0; i < length; i++) {
            nums[(i + k) % length] = temp[i];

//解释： i为当前位置k是当前位置平移的位置，
//超过的部分就是多出来的%length就是超出部分应该在的下标
        }
    }


}

改进方法二

例如:数组1，2，3，4，5，6，7 转3次
第一步: 先转化为7，6，5，4，3，2，1
第二步 转化为 5，6，7，4，3，2，1
第三步 转化为 5，6，7，1，2，3，4
分为三次转

class Solution {

public void reveres (int nums[],int start, int end){
    int i=(end-start)/2;
    for(int j=0;j<=i;j++){
        int temp=nums[start];
        nums[start]=nums[end];
        nums[end]=temp;
        start++;end--;
    }

}
 public void rotate(int nums[], int k) {
        k=k%nums.length;
        if(k==0||nums.length==1||nums.length==0){
            return;
        }
        
        reveres(nums,0,nums.length-1);
        reveres(nums,0,k-1);
        reveres(nums,k,nums.length-1);
    }

}

总结: 算法的时间复杂度与循环次数有很大关系，尽量少用嵌套循环