Arrays 排列数组，使其在递增和递减之间交替

如果不同整数的数组X[1..n]在递增和递减之间交替，则该数组是摆动的：对于每个奇数索引i，X[i]X[i+1]。例如，以下16元素阵列不稳定：

12、13、0、16、13、31、5、7、-1、23、8、10、-4、37、17、42

描述并分析一种算法，该算法排列给定阵列的元素以使阵列摆动

我的尝试：

想到的更明显的解决方案是对原始数组进行排序，将其分成两半，然后在每个子数组之间交替，抓住数组中的第一个元素以创建摆动数组。这将需要O（nlogn）。（编辑：刚刚意识到这只在所有整数都是不同的情况下才有效。）我忍不住想有一种更有效的方法来实现这一点

这怎么可能呢

---

（这不是一个家庭作业问题）

我能想到的最直接的方法是对数组进行排序，然后选择剩余的最低和最高元素

例如，使用您的示例列表，排序为：

-4 -1 0 5 7 8 10 12 13 13 16 17 23 31 37 42

结果就是

-4 42 -1 37 0 31 5 23 7 17 8 16 10 13 12 13

---

但是，我认为如果中间有相同的元素，则会出现这种情况，因此在这种情况下，您可能需要在序列末尾进行一些手动值替换，以恢复“摆动”约束。

我能想到的最直接的方法是对数组进行排序，然后交替使用剩余的最低和最高元素

例如，使用您的示例列表，排序为：

-4 -1 0 5 7 8 10 12 13 13 16 17 23 31 37 42

结果就是

-4 42 -1 37 0 31 5 23 7 17 8 16 10 13 12 13

---

但是，我认为如果中间有相同的元素，则会出现这种情况，因此在这种情况下，您可能需要在序列末尾进行一些手动值替换，以恢复“摆动”约束。

我能想到的最直接的方法是对数组进行排序，然后交替使用剩余的最低和最高元素

例如，使用您的示例列表，排序为：

-4 -1 0 5 7 8 10 12 13 13 16 17 23 31 37 42

结果就是

-4 42 -1 37 0 31 5 23 7 17 8 16 10 13 12 13

---

但是，我认为如果中间有相同的元素，则会出现这种情况，因此在这种情况下，您可能需要在序列末尾进行一些手动值替换，以恢复“摆动”约束。

我能想到的最直接的方法是对数组进行排序，然后交替使用剩余的最低和最高元素

例如，使用您的示例列表，排序为：

-4 -1 0 5 7 8 10 12 13 13 16 17 23 31 37 42

结果就是

-4 42 -1 37 0 31 5 23 7 17 8 16 10 13 12 13

但是，我认为如果中间有相同的元素，则会出现这种情况，因此在这种情况下，您可能需要在序列末尾进行一些手动值替换，以恢复“摆动”约束。

[3年后…：-）]

您的问题定义声明所有数组元素都是不同的。所以，你可以比排序做得更好——排序做得太多了

假设您有一个由第一个

k

元素构成的摆动序列。序列中的最后两个元素可能有两种情况：

A[k-1]

A[k-1]>A[k]

情况1：如果

A[k+1]

，则无需执行任何操作，因为抖动已保持。但是，如果

A[k+1]>A[k]

，则交换它们将确保恢复抖动

案例2：如果

A[k+1]>A[k]

，则无需执行任何操作，因为摆动已经保持。但是，如果

A[k+1]

，则交换它们将确保恢复抖动

这将为您提供一个

O（n）

time和

O（1）

space算法（因为您正在原地交换）。你的基本情况是当k=2，这是轻微的摆动

以下是Python3中的一个实现：

def rearrange_wobbly(A):
    if len(A) < 3:
        return A
    for i in range(2, len(A)):
        if A[i - 2] < A[i - 1] < A[i] or A[i - 2] > A[i - 1] > A[i]:
            # Swap A[i] and A[i - 1]
            A[i - 1], A[i] = A[i], A[i - 1]

>>> A = [x for x in range(10)]
>>> A
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(A)
>>> A
[3, 2, 1, 0, 7, 6, 9, 8, 4, 5]
>>> rearrange_wobbly(A)
>>> A
[3, 1, 2, 0, 7, 6, 9, 4, 8, 5]

def重新排列抖动（A）：
如果len（A）<3：
归还
对于范围（2，len（A））中的i：
如果A[i-2]A[i-1]>A[i]：
#交换A[i]和A[i-1]
A[i-1]，A[i]=A[i]，A[i-1]
>>>A=[x代表范围（10）内的x]
>>>A
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>随机。洗牌（A）
>>>A
[3, 2, 1, 0, 7, 6, 9, 8, 4, 5]
>>>重新排列_摆动（A）
>>>A
[3, 1, 2, 0, 7, 6, 9, 4, 8, 5]

[三年后…：-）]

您的问题定义声明所有数组元素都是不同的。所以，你可以比排序做得更好——排序做得太多了

假设您有一个由第一个

k

元素构成的摆动序列。序列中的最后两个元素可能有两种情况：

A[k-1]

A[k-1]>A[k]

情况1：如果

A[k+1]

，则无需执行任何操作，因为抖动已保持。但是，如果

A[k+1]>A[k]

，则交换它们将确保恢复抖动

案例2：如果

A[k+1]>A[k]

，则无需执行任何操作，因为摆动已经保持。但是，如果

A[k+1]

，则交换它们将确保恢复抖动

这将为您提供一个

O（n）

time和

O（1）

space算法（因为您正在原地交换）。你的基本情况是当k=2，这是轻微的摆动

以下是Python3中的一个实现：

def rearrange_wobbly(A):
    if len(A) < 3:
        return A
    for i in range(2, len(A)):
        if A[i - 2] < A[i - 1] < A[i] or A[i - 2] > A[i - 1] > A[i]:
            # Swap A[i] and A[i - 1]
            A[i - 1], A[i] = A[i], A[i - 1]

>>> A = [x for x in range(10)]
>>> A
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(A)
>>> A
[3, 2, 1, 0, 7, 6, 9, 8, 4, 5]
>>> rearrange_wobbly(A)
>>> A
[3, 1, 2, 0, 7, 6, 9, 4, 8, 5]

def重新排列抖动（A）：
如果len（A）<3：
归还
对于范围（2，len（A））中的i：
如果A[i-2]A[i-1]>A[i]：
#交换A[i]和A[i-1]
A[i-1]，A[i]=A[i]，A[i-1]
>>>A=[x代表范围（10）内的x]
>>>A
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>随机。洗牌（A）
>>>A
[3, 2, 1, 0, 7, 6, 9, 8, 4, 5]
>>>重新排列_摆动（A）
>>>A
[3, 1, 2, 0, 7, 6, 9, 4, 8, 5]