按顺序排列偶数和奇数

Question

我试图在一次通过时将偶数和奇数分别向左和向右分离。 另外，我想确保这些数字按升序排序，这样整个逻辑的复杂度为 O(n)。

例如，如果我的输入是 {9,8,2,3,11,10,1}；

这个逻辑我将 o/p 实现为 {10 8 2 3 11 9 1 } 但我想确保我的输出在同一次传递中被排序为 { 2,8,10,1,3,9,11}。

static void segregateEvenOdd(int arr[]) {
    /* Initialize left and right indexes */
    int left = 0, right = arr.length - 1;
    while (left < right) {
        /* Increment left index while we see 0 at left */
        while (arr[left] % 2 == 0 && left < right)
            left++;

        /* Decrement right index while we see 1 at right */
        while (arr[right] % 2 == 1 && left < right)
            right--;

        if (left < right) {
            /* Swap arr[left] and arr[right] */
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}

Answer 1

使用可让您传递Comparator的Sort 重载。 比较函数应该如下所示（伪代码）：

Comparison(a, b)
{
    if (Even(a) && !Even(b))
        return -1; // a < b
    if (Even(b) && !Even(a))
        return 1; // a > b
    // both are even, or both are odd.
    if (a < b) return -1;
    if (a > b) return 1;
    return 0;
}

Answer 2

您还可以使用列表：

List<Integer> list = Arrays.asList(yourArray);
Collections.sort(list, new Comparator<Integer>() {
       public int compare(Integer a, Integer b) {
                return a%2 - b%2;
       }
}

Answer 3

我正在尝试一次将左和右的偶数和奇数分开。 另外，我想确保这些数字按升序排序，这样整个逻辑将具有O（n）的复杂度。

例如，如果我的输入是{9,8,2,3,11,10,1};

我将此逻辑实现为{10 8 2 3 11 9 1}，但我想确保我的输出在同一遍中被排序为{2,8,10,1,3,9,11}。

static void segregateEvenOdd(int arr[]) {
    /* Initialize left and right indexes */
    int left = 0, right = arr.length - 1;
    while (left < right) {
        /* Increment left index while we see 0 at left */
        while (arr[left] % 2 == 0 && left < right)
            left++;

        /* Decrement right index while we see 1 at right */
        while (arr[right] % 2 == 1 && left < right)
            right--;

        if (left < right) {
            /* Swap arr[left] and arr[right] */
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}

Answer 4

这不可能一蹴而就。 你真的有两种不同的类型。 一个用于偶数，一个用于赔率。

这是我的建议。

解决方案 1。

如果您被允许引入新的数据结构，请采用以下方法创建两个 ArrayList（一个用于偶数，一个用于奇数）将它们适当地分开。 运行 Collections.Sort 两者。 迭代地重新填充初始数组。

解决方案 2。

使用上面的方法正确分离偶数和赔率。 计算列表中的偶数。 构建一个典型的排序例程，如 mergesort，并在数组的两个不同段上调用该例程。 上面的例子会被称为

merge(arr, 0, 2);
merge(arr, 3, 6);

这两种解决方案的总体时间复杂度为：O(nlogn)。 空间复杂度：O(n)。 解决方案一更容易实施，但解决方案二允许您进行更多就地排序。 其他排序例程具有最佳情况 O(n) 时间但不保证。

Answer 5

我会使用快速排序或任何其他标准算法，但将元素之间的比较定义为：如果a是偶数且b是奇数，或者它们是偶数或奇数且a<b ，则a小于b 。

这不会给你 O(n)，这是不可能的，但会通过重用众所周知的算法来最大化性能。