給定一個數組，將數組中的元素向右移動 k 個位置，其中 k 是非負數。
示例 1:
輸入: [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:
輸入: [-1,-100,3,99] 和 k = 2
輸出: [3,99,-1,-100]
解釋:
向右旋轉 1 步: [99,-1,-100,3]
向右旋轉 2 步: [3,99,-1,-100]
說明:
盡可能想出更多的解決方案，至少有三種不同的方法可以解決這個問題。
要求使用空間復雜度為 O(1) 的原地算法。
我的解答：
class Solution {
public void rotate(int[] nums, int k) {
if (nums == null || nums.length == 0 || k==0) {
return;
}
int temp ,temp2;
int length = nums.length;
if (k > length) {
k = k%length;
}
k = k%length;
if (length == k || k==0) {
return;
}
int count =0;
out:for (int i = length - 1; i >= length - 1 - k; i--) {
temp = nums[i];
for (int j = (i + k) % length; j <= i; j = (j + k) % length) {
temp2 = nums[j];
nums[j] = temp;
temp = temp2;
count ++;
if (count == length) {
break out;
}
if (j == i) {
break;
}
}
}
}
}
/**
* 大概思路是，從數組的末尾開始，把現在的數據放到每隔K的位置上，
* 超過了數組長度，就取余。
* 如果執行了一圈，回到了開始替換的位置，那么執行下一圈。
*比如：
原始數組：[1,2,3,4]
第一次把4放到數組第二的位置，並把2緩存起來
數組：[1,4,3,4]
第二次把數組第四的位置，緩存起來，並把緩存的2放到數組第四的位置，
數組：[1,4,3,2]
這時候發現又回到了原來的位置，那么本次循環結束，從第三個位置開始，繼續循環
數組：[3,4,3,2]
數組：[3,4,1,2]
數組：[3,4,1,2]
* 如果執行過程中從來沒回到過原來的位置，那么替換N 次以后，就是
* 最終的數組，所有的數據都換了一下位置。
*比如：
* 原始數組：[1,2,3,4,5]
* 第一次，把第五的位置數組，放到第二個，因為k是2，並且第二個位置的2 要緩存起來
* 數組：[1,5,3,4,5]
* 第二次，把第四個位置的4緩存起來，然后把緩存的2放到第四個位置
數組：[1,5,3,2,5]
第三次，把第一個位置的1緩存起來，然后把緩存的4放到第一個位置
數組：[4,5,3,2,5]
這種是永遠都不會回到之前替換過的位置，替換N次結束即可
數組：[4,5,1,2,5]
數組：[4,5,1,2,3]
數組：[4,5,1,2,3]
*
* 時間復雜度是n*k,網上最快的算是0m，說實話，我有點不服氣
* 因為他們用了新的數組，開辟了新的內存空間。
* 我錯了，時間復雜度是O（n） ，不是O（n*K）
* 因為當執行了n次之后，雙層循環就會結束。
*
* @param nums
* @param k
*/
網上最快的算法：
但是這種算法，額外開辟了空間。我覺得有違題的意思。
class Solution {
public void rotate(int[] nums, int k) {
k=k%nums.length;
int[] tmp=nums.clone();
System.arraycopy(tmp,tmp.length-k,nums,0,k);
System.arraycopy(tmp,0,nums,k,tmp.length-k);
}
}