将数组转换为 Zig-Zag 时尚

在程序设计中，经常需要对数组进行排序或转换操作。其中一种常见的转换是将数组转换为 Zig-Zag 时尚。这种转换是指，通过交替上升和下降的方式重新排列数组元素，使得相邻元素的大小关系满足一定的条件。本文将介绍如何实现这种转换。

方法一：暴力法

暴力法的思想是直接枚举所有可能的排列，然后计算每个排列的正确性。具体而言，我们先将数组排序，然后枚举所有可能的两两交换位置，计算交换后数组的大小关系是否满足要求。如果有符合要求的排列，我们就返回这个排列。时间复杂度为 $O(n!)$，显然不适用于大规模问题。

// Java 代码片段
public int[] zigzag(int[] nums) {
    int n = nums.length;
    int[] copy = Arrays.copyOf(nums, n);
    Arrays.sort(copy);
    do {
        boolean flag = true;
        for (int i = 1; i < n - 1; i++) {
            if ((copy[i] > copy[i - 1] && copy[i] > copy[i + 1]) || (copy[i] < copy[i - 1] && copy[i] < copy[i + 1])) {
                continue;
            }
            flag = false;
            break;
        }
        if (flag) {
            int[] result = new int[n];
            for (int i = 0, j = 0; i < n; i += 2, j++) {
                result[i] = copy[n / 2 - j - 1];
            }
            for (int i = 1, j = 0; i < n; i += 2, j++) {
                result[i] = copy[n / 2 + j];
            }
            return result;
        }
    } while (nextPermutation(copy));
    return new int[n];
}

private boolean nextPermutation(int[] nums) {
    int i = nums.length - 2;
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }
    if (i < 0) {
        return false;
    }
    int j = nums.length - 1;
    while (j > i && nums[j] <= nums[i]) {
        j--;
    }
    swap(nums, i, j);
    for (int k = i + 1, l = nums.length - 1; k < l; k++, l--) {
        swap(nums, k, l);
    }
    return true;
}

private void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

方法二：单次遍历法

暴力法的时间复杂度太高，需要寻找更高效的解法。我们观察 Zig-Zag 时尚的特点，发现任意相邻的三个元素 $a_i, a_{i+1}, a_{i+2}$ 必然满足 $a_i > a_{i-1}, a_i > a_{i+1}$ 或者 $a_i < a_{i-1}, a_i < a_{i+1}$。因此，我们可以从前往后遍历数组，维护当前的大小关系，并在遇到不满足要求的元素时进行交换。如果当前处于上升段且当前元素大于等于下一个元素，或者当前处于下降段且当前元素小于等于下一个元素，我们就交换这两个元素即可。时间复杂度为 $O(n)$，空间复杂度为 $O(1)$。

# Python 代码片段
def zigzag(nums):
    n = len(nums)
    flag, i = True, 0
    while i < n - 1:
        if (flag and nums[i] > nums[i + 1]) or (not flag and nums[i] < nums[i + 1]):
            nums[i], nums[i + 1] = nums[i + 1], nums[i]
        i += 1
        flag = not flag
    return nums

方法三：坐标变换法

还有一种技巧性比较强的方法是坐标变换法。我们可以将 Zig-Zag 时尚转换为一条线段的形式，然后通过改变坐标系将这条线段变成一个锯齿状。具体而言，设数组 $nums$ 的长度为 $n$，我们可以将它映射成如下的凸包图形：

$$ \begin{matrix}(-n/2, nums[0]) \dots (-1, nums[n/2-1])\;;;\;;; (0, nums[n/2]) ;;;\dots (n/2-1, nums[n-1])\end{matrix} $$

其中括号中的第一个数表示横坐标，第二个数表示纵坐标。然后我们可以通过改变坐标系的方式，将图形变成如下的形式：

$$ \begin{matrix}(0, nums[0]) \dots (n/2-1, nums[n/2-1])\;\(1, nums[n/2]) \dots (n/2, nums[n-1])\;\(n/2, nums[n/2])\end{matrix} $$

具体而言，我们将纵坐标为偶数的点沿着横坐标递增的方向平移 $1$ 个单位，将纵坐标为奇数的点沿着横坐标递减的方向平移 $1$ 个单位。这样，每个点的左右两个邻居都满足大小关系的要求。时间复杂度为 $O(n)$，空间复杂度为 $O(1)$。

// Java 代码片段
public int[] zigzag(int[] nums) {
    int n = nums.length;
    int[] result = new int[n];
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) {
            result[i] = nums[i / 2];
        } else {
            result[i] = nums[n - i / 2 - 1];
        }
    }
    return result;
}

总结

本文介绍了三种将数组转换为 Zig-Zag 时尚的方法。暴力法是最简单直接的方法，但时间复杂度极高，不适用于大规模问题。单次遍历法通过逐个交换不满足大小关系的元素，达到了线性时间复杂度。坐标变换法技巧性较高，但可以达到与单次遍历法一样的时间复杂度，并且空间复杂度更低。不同的场景可能适用不同的方法，需要根据实际情况进行选择。