数组循环旋转说明

Question

前提：我的问题不是 Cyclic rotation in Python 的重复。我不是在问如何解决问题或为什么我的解决方案不起作用，我已经解决了它并且它有效。我的问题是关于我发现的同一问题的另一种特定解决方案，因为我想了解其他解决方案背后的逻辑。

我遇到了以下循环数组旋转问题（在源代码下方）：

• Cyclic rotation in Python
• https://app.codility.com/programmers/lessons/2-arrays/cyclic_rotation/

给定一个由 N 个整数组成的数组 A。数组的旋转意味着每个元素右移一个索引，并且数组的最后一个元素移动到第一位。例如，数组 A = [3, 8, 9, 7, 6] 的旋转为 [6, 3, 8, 9, 7] （元素右移一个索引，6 移到第一位）。 目标是将数组 A 旋转 K 次；也就是A的每个元素都会右移K次。

我设法用以下 Python 代码解决了这个问题：

def solution(A , K):
    N = len(A)
    if N < 1 or N == K:
        return A
    K = K % N
    for x in range(K):
        tmp = A[N - 1]
        for i in range(N - 1, 0, -1):
            A[i] = A[i - 1]
        A[0] = tmp
    return A

然后，在以下网站https://www.martinkysel.com/codility-cyclicrotation-solution/ 上，我找到了以下针对同一问题的奇特解决方案：

def reverse(arr, i, j):
    for idx in xrange((j - i + 1) / 2):
        arr[i+idx], arr[j-idx] = arr[j-idx], arr[i+idx]

def solution(A, K):
    l = len(A)
    if l == 0:
        return []

    K = K%l

    reverse(A, l - K, l -1)
    reverse(A, 0, l - K -1)
    reverse(A, 0, l - 1)

    return A

有人能解释一下这个特殊的解决方案是如何工作的吗？ （作者在他的网站上没有解释）

我的解决方案对于大型A 和K 表现不佳，其中K < N，例如：

    A = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] * 1000
    K = 1000
    expectedResult = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] * 1000
    res = solution(A, K) # 1455.05908203125 ms = almost 1.4 seconds

因为对于K < N，我的代码的时间复杂度为O(N * K)，其中N是数组的长度。 对于大 K 和小 N (K > N)，由于模运算 K = K % N，我的解决方案表现良好：

    A = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    K = 999999999999999999999999
    expectedRes = [2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
    res = solution(A, K) # 0.0048828125 ms, because K is torn down to 9 thanks to K = K % N

另一方面，另一种解决方案在所有情况下都表现出色，即使在 N > K 并且复杂度为 O(N) 时也是如此。

该解决方案背后的逻辑是什么？

感谢您的关注。

Answer 1

这是一个非常简单的 Ruby 解决方案。 （在代码中得分 100%） 删除数组中的最后一个元素，并将其插入到开头。

def solution(a, k)
  if a.empty?
    return []
  end
  modified = a
  1.upto(k) do 
    last_element = modified.pop
    modified = modified.unshift(last_element)
  end
  return modified
end

Answer 2

让我先谈谈K < N的基本情况，这种情况下的想法是将数组分成两部分A和B，A是第一个NK元素数组，B是最后 K 个元素。算法分别反转A和B，最后反转整个数组（两部分分别反转）。要使用K > N 处理这种情况，请认为每次反转数组 N 次都会再次获得原始数组，因此我们可以使用模块运算符找到拆分数组的位置（仅反转真正有用的时间，避免无用的移位)。

图形示例

图形分步示例有助于更好地理解概念。请注意

• 粗线表示数组的分割点（本例中为K = 3）；
• 红色数组表示输入和预期输出。

起点：

看看我们想要在最终输出前面的最后 3 个字母反转，现在让它反转（算法的第一个反转）：

现在反转前 N-K 个元素（算法的第二个反转）：

我们已经有了解决方案，但是在相反的方向，我们可以通过反转整个数组来解决它（算法的第三个也是最后一个反转）：

这里是最终输出，原始数组循环旋转了 K = 3。

代码示例

让我们再举一个 Python 代码的分步示例，从：

A = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
K = 22
N = len(A)

我们找到分裂指数：

K = K%N
#2

因为，在这种情况下，前 20 个移位将没有用，现在我们将原始数组的最后 K(2) 个元素反转：

reverse(A, N-K, N-1)
# [1, 2, 3, 4, 5, 6, 7, 8, 10, 9]

如您所见，9 和 10 已经移位，现在我们反转前 N-K 个元素：

reverse(A, 0, N-K-1)
# [8, 7, 6, 5, 4, 3, 2, 1, 10, 9]

最后，我们反转整个数组：

reverse(A, 0, N-1)
# [9, 10, 1, 2, 3, 4, 5, 6, 7, 8]

请注意，反转数组的时间复杂度为 O(N)。