Rotate Array（3 ways）

Rotate an array of n elements to the right by k steps.

For example, with n = 7 and k = 3, the array [1,2,3,4,5,6,7] is rotated to [5,6,7,1,2,3,4].Could you do it in-place with O(1) extra space?

Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.

/*方法1：将新数组与原数组比较可找出规律：k=3时即将最后3个数移动到数组最前面，
 * 相当于先将1~4逆转成4,3,2,1，再将5~7逆转成7,6,5，最后再将整个数组逆转成5,6,7,1,2,3,4。
 * 所以添加一个函数reverse()作为逆转使用。时间复杂度为O(n)
 */
public class Solution {
  public void reverse(int[] nums, int l, int h){
		int temp = 0;
		while (l < h ){
			temp = nums[l];
			nums[l ++] = nums[h];
			nums[h --] = temp;
		}
	}
  public void rotate(int[] nums, int k) {
  	int len = nums.length;
  	k %= len; //一开始是考虑对k进行判断，若k超过数组长度即报错，运行之后才发现系统默认循环移动，所以用到该语句，这是关键
  	if (k == 0){
  	    return;
  	}
  	if (len - k > 1){
  	    reverse(nums, 0, len - k - 1);
  	}
  	if (k > 1){
  	    reverse(nums, len -k, len - 1);
  	}
  	reverse(nums, 0 , len - 1);
  }
}


/*方法2：直接对数组元素依次进行移动，如k=3时，理应将5,6,7分别移动到数组最前面，
 * 一开始尝试的将7先保存到temp,然后将1~6依次后移一位，然后将6保存进temp，
 * 将1~5依次后移一位，最后将5保存进temp，然后将1~4后移。但是leetcode会报超时错误，
 * 进一步优化后，完成了下面的代码实现。时间复杂度为k * O(n - k)
 */
public class Solution {
    public void rotate(int[] nums, int k) {
    	int i = 0;
    	int temp = 0;
    	int len = nums.length;
    	k %= len;
    	for (i = 0; i < k; i ++){
    		temp = nums[len - k + i];
    		for (int j = len - k + i; j > i; j --){ 
//从5开始置temp，然后移动1~4，再将6置temp，移动1~4…这样每一步就分别省去了6,7的移动，leetcode运行通过
    			nums[j] = nums[j - 1 ];
    		}
    		nums[i] = temp;
    	}
    }
}

/*方法3：将数组元素从末尾(i = len - 1)开始每k个进行位置对换，如1,2,3,4,5,6,7,k = 3,
 * 先将5,6,7和2,3,4对换，变成1,5,6,7,2,3,4，此时i指向7，i - 3指向1的位置，
 * 继续将7和1交换，得到7,5,6,1,2,3,4，i - 3 < 0停止交换，最后将前k个数调整位置成5,6,7
 */
public class Solution {
    public void rotate(int[] nums, int k) {
    	int len = nums.length;
    	k %= len;
    	if (k == 0){
    		return;
    	}
    	int i = len - 1;
    	int temp = 0;
    	int t;
    	while (i - k >= 0){//每k个进行交换，时间复杂度为k * O(n/k) = O(n)
    		t = k;
    		while ((i - k >= 0) && (t > 0)){
    			temp = nums[i];
    			nums[i] = nums[i - k];
    			nums[i - k] = temp;
    			i --;
    			t --;
    		}
    	}
    	t = len % k;
    	if (t == 0){//若k正好能被元素个数整除，则无需再对前k个元素进行处理
    	    return;
    	}
    	else {//t不为0时，说明元素没有正好按每k个进行交换，所以前k个元素的位置需要根据t的大小进行交换，时间复杂度为(n % k) * O(k)
    		while (t > 0){
    			i = 0;
    			temp = nums[0];
    			while (i + 1 < k){
    				nums[i] = nums[i + 1];
    				i ++;
    				}
    			nums[i] = temp;
				t --;
    			}
    		}
    		return;
    }
}