題目描述

給定一個數組，將陣列中的元素向右移動 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) 的 原地 演算法。

題解

先決知識

定義一個數N的加法域，例如5的加法域，那麼它包含的元素就是{0,1,2,3,4}

定義加法：設p是域中一個元素，有其他數k，那麼加法為p2=p+k，有如下結論：

• 如果N和k互素，那麼域中任何一個元素都是這個域的加法生成元

• 如果N和K不互素，並且最大公約數為C，那麼N的這個加法域可以分為N/C個部分，分別為一個子域，並且子域中任意元素都是該子域的加法生成元

演算法

首先求陣列長度length和k的最大公約數：

• 如果公約數為1，那麼說明了他們互素，由前面先決知識可知，陣列中任意元素都是一個生成元，可以由任意數通過這個加法遍歷到陣列中所有元素

  • 設定一個迴圈，迴圈的次數為陣列的長度，從陣列任意位置開始，然後每次執行的操作是將上一個數挪動到它最終應該待的地方，然後將目標位置的數存到一個臨時變數中

  • 繼續下一次迴圈，將臨時變數中的元素儲存到它最終應該待的位置，將目標位置的元素儲存到臨時變數

  • 重複上述迴圈可以遍歷完整個陣列

• 如果最大公約數不為1，說明了他們不是互素的，由先決條件可知，我們需要將他們分為N/C個子域，然後對每個子域執行互素時的操作

  • 易得，陣列中連續C個元素是分別屬於C個子域的元素，由這C個元素可以通過加法遍歷到整個陣列

程式碼

func rotate(nums []int, k int) {
    length := len(nums)
    k %= length
    if k == 0 {
        return
    }
    // 此時求length和k的最大公約數
    dividend, comDivisor := length, k
    for {
        tmpDividend, tmpDivisor := comDivisor, dividend%comDivisor
        if tmpDivisor == 0 {
            break
        }
        dividend, comDivisor = tmpDividend, tmpDivisor
    }
    var times, elemNum int
    // 重啟迴圈的次數
    if comDivisor == 1 {
        times, elemNum = 1, length
    } else {
        times, elemNum = comDivisor, length/comDivisor
    }
    for i := 0; i < times; i++ {
        index := i
        tmp := nums[length-k+i]
        for j := 0; j < elemNum; j++ {
            tmp, nums[index], index = nums[index], tmp, (index+k)%length
        }
    }
}

tips

今天寫程式碼犯了一個錯，我還在想為什麼我向函式傳的是陣列，也就是傳的是陣列的指標（地址），為什麼修改了陣列的值，在外層函式中沒有效果，我的程式碼如下：

package main
​
import (
    "fmt"
)
​
func main() {
    a := []int{2, 3, 4}
    test(a)
    fmt.Println(a)
    test2(a)
    fmt.Println(a)
}
​
func test(a []int) {
    b := []int{1, 2, 3}
    // a只是一個識別符號，這裡a已經指向了另一個記憶體地址了，所以這個a已經不是外層函式的那個a了
    a = b
}
​
func test2(a []int) {
    // a仍然是一個識別符號，但是a和外層函式的a指向的是同一個記憶體地址，所以此時在函式內部修改陣列元素是有效的
    a[0] = 5
}