Question

我被要求重新排序一个数组，以便n跟随m的每个实例。我知道数组中n和m的数量相等。例如，如果每3个跟随4个

[3,2,2,4] = [3,4,2,2]
[1,3,1,4,4,3,1] = [1,3,4,1,1,3,4]

我已经成功地解决了这个问题的大多数情况，除了上面的例子中的一些情况，第二个工作除了最后3个。我编写代码的方式是搜索其余的另一个4的数组，但它发生在最后一个3之前。下面是我的代码，

public static int[] reOrder(int[] arr) {
    int temp;

    for(int i = 0; i < arr.length; i++) {
        if(arr[i] == 3) {
            for(int j = i; j < arr.length; j++) {
                if(arr[j] == 4) {
                    temp = arr[i+1];
                    arr[i+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    return arr;
}

Answer 1

你应该为3和4使用单独的指针，在内存中保持最右边4位，所以代码应如下所示：

public static int[] reOrder(int[] arr) {
    int temp;
    for(int i = 0, j = 0; i < arr.length; i++) {
        if(arr[i] == 3 && i != arr.length - 1 && arr[i+1] != 4) { // we need to do it only if successor isn't 4, and position isn't last
            while (j < arr.length && arr[j] != 4 || (j > 0 && arr[j-1] == 3)) { //searching for first unused '4' in array
                j++;
            }
            if (arr[j] == 4) {
                temp = arr[i+1];
                arr[i+1] = arr[j];
                arr[j] = temp;
                j++;
            }
        }
    }
    return arr;
}

Answer 2

以下是如何在一行中完成的：

public static int[] reOrder(int[] arr) {
    return IntStream.of(arr).filter(i -> i != 4)
        .flatMap(i -> i == 3 ? IntStream.of(3, 4) : IntStream.of(i))
        .toArray();
}

或更好，参数化：

public static int[] reOrder(int[] arr, int n, int m) {
    return IntStream.of(arr).filter(i -> i != n)
        .flatMap(i -> i == m ? IntStream.of(m, n) : IntStream.of(i))
        .toArray();
}

这可以通过流式传输来首先删除所有“n”值，然后在每个“n”之后插入“m”。鉴于已知n和m的计数相同，这种方法是安全的。

这段代码的时间复杂度是O（n）（即它是一次通过值），而你的代码是O（n ²）。

重新排序数组，因此n跟随m

2 个答案: