Question

我尝试解决geeksforgeeks.org上有关“交替排列数组”的问题，尝试输入示例时，我没有收到任何错误，但是当我尝试提交它时，却收到了“内存错误” < / p>

test_cases = "1"
for _ in range(int(test_cases)):
    new_array = []
    array_size = int("89")
    array = list(map(int, "1 9 16 18 72 88 98 100 127 128 150 155 160 174 185 196 198 200 218 226 267 270 279 284 299 309 326 335 335 351 355 369 383 394 399 400 413 422 422 429 438 440 446 483 507 529 529 542 553 556 567 571 578 594 611 640 642 652 658 658 663 673 694 717 723 736 762 763 775 777 778 784 806 816 828 851 853 854 889 891 911 932 953 955 958 973 977 986 998 ".split()))
    while len(array) != 0:
        if len(array) == 1:
            new_array.append(array[0])
            array.remove(array[0])
        else:
            max_array_value = max(array)
            min_array_value = min(array)
            new_array.append(max_array_value)
            new_array.append(min_array_value)
            array.remove(max_array_value)
            array.remove(min_array_value)

*旁注：让我们忽略为什么我以字符串格式而不是整数使用它，因为我试图复制geeksforgeeks.org的输入。 *

当前代码仅适用于小型阵列，不适用于大型阵列。当我尝试创建超过100个整数的列表时，它将给我错误。我想知道是否可以解决这个问题？

Answer 1

def rearrange(arr, n): 

    k,j=1,1
    a=[0]*n
    for i in range(0,n):

        if i%2==0:
            a[i]=arr[n-k]
            k=k+1

        else:
            a[i]=arr[i-j]
            j=j+1
    for i in range(n):
        arr[i]=a[i]

Answer 2

下面提到的解决方案使用解决O(N)时间复杂度和O(1)空间复杂度WITHOUT的问题>“在一个位置概念上存储 2 个值”。此外，该算法还可以处理重复值和浮点值，因为输入列表是非递减排序的并且仅由正实数组成。

PS：如果您愿意，可以稍微修改我的算法，使其也适用于负值。

请不要被代码吓倒。实现非常简单。
算法可能有点难以理解。

    def reArrange(arr, print_arr_state=True):
        # arr: non-decreasingly sorted list of positive floats/ints
        length = len(arr)
        for i in range(length):
            if arr[i] > 0:
                cycler(arr, i, length, print_arr_state)
            arr[i] = abs(arr[i]) # This is the tricky part
            # printing the array after every iteration
            if print_arr_state:
                print('after', i, 'th iteration:', arr)


    def cycler(arr, start_index, length, print_cycler_array=True):
        if print_cycler_array:
            print('cycler function:', arr, end=' ---> ')

        half_length_index = length // 2
        swap_index = start_index
        current_value = arr[start_index]
        while True:
            if swap_index < half_length_index:
                swap_index = 2 * swap_index + 1
            else:
                swap_index = 2 * (length - 1 - swap_index)

            # Placing the current value at swap_index and making the making current_value variable refer to the value which was at swap_index
            swap_value = arr[swap_index]
            arr[swap_index] = -1 * current_value # -1 * ?? This is the tricky part of the algo
            current_value = swap_value

            # cycler function will not stop until the simple cycle is complete
            # simple cycle is complete when swap_index == start_index
            if swap_index == start_index:
                if print_cycler_array:
                    print(arr)
                return

提供输入（input_array）并调用重新排列函数：

input_array = [0.1, 2, 3.2, 3.3, 3.3, 4, 5.7, 5.7, 6.8, 7, 8, 9]
reArrange(input_array)

输出：

answer_array = [9, 0.1, 8, 2, 7, 3.2, 6.8, 3.3, 5.7, 3.3, 5.7, 4]

理解算法

算法的棘手部分：

每个值都恰好属于 1 个循环，这个循环是一个简单的循环（图中的简单循环 vs 复杂循环）。 cycler 函数执行一次对应一个循环，也是一个简单的循环。

每当我在一个循环中覆盖一个值时，我都会将它乘以 -1（表示它被覆盖）并将其存储在输入数组本身中。在 reArrange 函数循环的第 i 次迭代期间，如果我发现第 i 个值为负，我会得到一个指示，表明该值是为某个 j 次执行的循环的一部分迭代（其中 j < i），因此我不会对该值调用 cycler 函数。但是如果这个值是正的（表明到目前为止执行的循环都没有覆盖这个值），这意味着它还没有被覆盖，因此应该在使用 cycler 的第 i 次迭代中覆盖功能。

但是等等！如果我将所有值乘以 -1，我的最终答案将是 -1 * correct_answer_array。为了解决这个问题，一个解决方案是重申我的answer_array（最初是input_array，现在已经转变为我的answer_array）并取绝对值每个值 OR 在我第一次也是唯一一次迭代（reArrange 函数的循环）期间，通过在移动到 i+1 之前取值的绝对值，我可以做同样的事情- 第一次迭代。

一些有效的问题

我在这篇文章中没有涉及这个算法的几个方面。让我以问题的形式给您留下其中的一些方面：

cycler 函数的 while 循环是否保证终止？
为什么我们不应多次覆盖一个值？
我们如何处理负输入值（如果有）？
单个循环是否足以覆盖 input_array 的所有值。（是不是一次调用 cycler 函数就足以覆盖所有值）？
提示：例如：1 2 3 4 5 6 7，这个例子将导致3个周期。（cycler 函数将被调用三次）
在单次调用循环器函数期间会发生什么？
提示：作为这个循环的一部分的每个值都会转移到它应该在 correct_answer_array 中的位置。一旦一个值处于正确的位置，就不应该再次受到干扰。

<块引用>

这个算法完全是一种全新的原创方法，所以更多的是验证它的人越多越好比“在一个位置概念上存储两个值”更好的选择。

请访问 this page (GeeksforGeeks) 底部的评论部分，查看算法的试运行。请确保您阅读了我的所有评论，因为它的部分内容已损坏。

交替重新排列阵列[内存错误]

2 个答案:

理解算法

算法的棘手部分：

一些有效的问题