使用linq排序int數組？

Question

問題

編寫程序以對任何給定的正負整數數組進行排序，以使正數跟隨負數，但是正負的相對位置保持不變。 像下面的示例（1）一樣，（-7）出現在（-5）之后，因此在排序數組（-7）之后是（-5）。

該程序應僅迭代給定數組一次，並且不應使用臨時數組。

示例1.給定數組：{2，4，-5，0，-7，-2，2，-5，1，-9，-7，-1}

排序數組：{-5，-7，-2，-5，-9，-7，-1、2、4、0、2、1}

示例2.給定數組：{-3，7，0，-2，-1，3，-3，9，5，-5，8}

排序數組：{-3，-2，-1，-3，-5、7、0、3、9、5、8}

我的解決方案

class Program
{
    public static void Main(string[] args)
    {
        var intArray = new int[] {  2, 4, -5, 0, -7, -2, 2, -5, 1, -9, -7, -1 };
        var sorted_intArray = SortIntArray(intArray);
        Console.WriteLine(String.Join(",", sorted_intArray));

        intArray = new int[] { -3, -2, -1, -3, -5, 7, 0, 3, 9, 5, 8 };
        sorted_intArray = SortIntArray(intArray);
        Console.WriteLine(String.Join(",", sorted_intArray));
        Console.ReadLine();
    }

    private static int[] SortIntArray(int[] intArray)
    {
        var sorted_intArray = intArray.GroupBy(_int => _int < 0 ? -1 : 1)// Create group of +ve and -ve numbers
                             .OrderBy(group => group.Key)  // Bring group of -ve number first
                             .SelectMany(groupedItems => groupedItems).ToArray(); // Select num from both Group and convert to array
        return sorted_intArray;
    }
}

題

i）問題陳述中說，數字僅應迭代一次，並且不應使用臨時數組。 我相信我使用linq的解決方案不滿足此要求。 如果可能的話，如何使用linq解決上述問題？

ii）在有或沒有linq的情況下，有什么其他可能有效的方法來解決上述問題？ 使用C / C ++的解決方案也可以。

Answer 1

根據此 OrderBy是穩定的，因此：

enumerable.OrderBy(x => x >= 0);

Answer 2

Linq很棒：

private static int[] SortIntArrayWithDuplicates(IEnumerable<int> intArray)
{
    var enumerable = intArray as int[] ?? intArray.ToArray();

    return enumerable.Where(x => x < 0)
        .Concat(enumerable.Where(x => x >= 0))
        .ToArray();
}

private static int[] SortIntArrayWithoutDuplicates(IEnumerable<int> intArray)
{
    var enumerable = intArray as int[] ?? intArray.ToArray();

    return enumerable.Where(x => x < 0)
        .Union(enumerable.Where(x => x >= 0))
        .ToArray();
}

Answer 3

您根本不需要分組。 使用OrderBy ，Linq-to-objects是“穩定的”（意思是它保持“重復”對象的原始順序），因此您可以僅根據數字是否小於零進行排序：

private static int[] SortIntArray(int[] intArray)
{
    var sorted_intArray = intArray.OrderBy(i => i < 0 ? 0 : 1).ToArray(); 
    return sorted_intArray;
}

輸出：

-5,-7,-2,-5,-9,-7,-1,2,4,0,2,1
-3,-2,-1,-3,-5,7,0,3,9,5,8

請注意，如果將返回類型更改為IEnumerable<int>則可以避免ToArray調用並減少內存使用量。

是否將Linq訂單計算為“重復一次”取決於誰給了您該要求。 我不知道可以一次完成任何排序算法。

有或沒有linq，有什么其他可能有效的方法可以解決上述問題？

好吧，我可以通過掃描所有數字，先取負數，然后再掃描，取所有非負數，來看看如何處理兩次 。 您可以使用yield語法簡化此操作：

private static IEnumerable<int> SortIntArray(int[] intArray)
{
    foreach(var i in intArray)
        if(i < 0) yield return i;
    foreach(var i in intArray)
        if(i >= 0) yield return i;
} 

Answer 4

我喜歡這些：

升序訂購

 enumerable.OrderBy(x => x); 

降序訂購

 enumerable.OrderByDescending(x => x);