排序数组，使所有正数首先出现

Question

我正在用 C# 编写代码来对数组进行排序，我想要右侧的所有负值和左侧的所有正值，不应该按降序排列

namespace SortApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] newInt = new int[] { 5, -2, -1, -4, -20, 6, 7, -14, 15, -16, 8, 9, 10 };
            int size = 12, i= 0;             // or newInt.Length

            for (i = 0; i < newInt.Length; i++)
            {
                if (newInt[i] < 0 && newInt[size] > 0)
                {
                    int temp = newInt[i];
                    newInt[i] = newInt[size];
                    newInt[size] = temp;
                    size--;
                }
            }
            for (i = 0; i < newInt.Length; i++)
            {
                Console.Write(newInt[i]);
                Console.Write(" ");
            }
        }
    }
}

但输出是这样的（-20 在错误的一边）：

5 10 9 8 -20 6 7 -14 15 -16 -4 -1 -2

但预期的输出是：

5 10 9 8 15 6 7 -14 -20 -16 -4 -1 -2 

为什么我的代码没有产生预期的输出？

Answer 1

您的解决方案错误地决定了何时结束循环。此外，它在循环头中无条件地增加i，并且从不减少size，即使它指向负数。

以下是解决方法：

for (i = 0; i < size ; ) {
    if (newInt[i] < 0 && newInt[size] >= 0) {
        int temp = newInt[i];
        newInt[i] = newInt[size];
        newInt[size] = temp;
        size--;
        i++;
        continue;
    }
    if (newInt[i] >= 0) {
        i++;
    }
    if (newInt[size] < 0) {
        size--;
    }
}

这是demo on ideone。

您可以为left 和right 指针使用更易读的标识符来重写此循环，而不是使用i 和size。这将使您的算法在代码中看起来更加“对称”，以识别其设计中的对称性：

int left = 0, right = newInt.Length-1;
while (left < right) {
    if (newInt[left] < 0 && newInt[right] >= 0) {
        int temp = newInt[left];
        newInt[left] = newInt[right];
        newInt[right] = temp;
        right--;
        left++;
        continue;
    }
    if (newInt[left] >= 0) {
        left++;
    }
    if (newInt[right] < 0) {
        right--;
    }
}

这里是an ideone link to the alternative implementation。

Answer 2

试试这个解决方案：

var newInt = new[] {5, -2, -1, -4, -20, 6, 7, -14, 15, -16, 8, 9, 10};
var solution = newInt.GroupBy(i => i > 0).
    SelectMany(g => g).
    ToArray();

您的算法的问题在于，当您减少size 时，您最终会使newInt[size] 指向一个负值，并且不会输入if 块。

Answer 3

一个相当简单的解决方案的总体思路是开始一个索引，在数组的开头将其称为left，在数组的末尾将另一个称为right。

递增left，直到找到负数，或直到left == right。当你遇到负数时，递减 right 直到找到正数，或者直到 right == left。

如果left 正在索引一个负数而right 正在索引一个正数，则交换这两项并再次开始增加left。

总体思路，未经测试：

int left = 0;
int right = a.Length-1;
while (left < right)
{
    if (a[left] < 0)
    {
        while (right > left)
        {
            if (a[right] >= 0)
            {
                // swap here
                int temp = a[left];
                a[left] = a[right];
                a[right] = temp;
                break;
             }
             --right;
        }
    }
    ++left;
}

Answer 4

这会以最少的循环产生所需的顺序

int[] newInt = new int[] { 5, -2, -1, -4, -20, 6, 7, -14, 15, -16, 8, 9, 10 };
int lt = 0;
int rt = newInt.Length - 1;
while (true) {
    // Find first negative number
    while (newInt[lt] >= 0 && lt < rt) {
        lt++;
    }

    // Find last positive number
    while (newInt[rt] < 0 && rt > lt) {
        rt--;
    }

    if (lt == rt) {
        break; // Finished
    }

    // Swap
    int temp = newInt[lt];
    newInt[lt] = newInt[rt];
    newInt[rt] = temp;
}
//TODO: Print result

Answer 5

如果您可以使用泛型和 linq，那么最简单的解决方案就是：

int[] newInt = new int[] { 5, -2, -1, -4, -20, 6, 7, -14, 15, -16, 8, 9, 10 };
newInt.ToList().Sort();
newInt.Reverse();
newInt = newInt.ToArray();

希望这会有所帮助！