就位排序为IList <T> ？

Question

.NET是否具有针对IList的就地排序功能？ 我需要对集​​合本身进行排序，而不是创建新集合。

编辑：我需要进行适当排序的原因是避免重新绘制UI，除非实际更改过。 如果只有一项不合适，我不想创建一百个新的自定义控件。

编辑：同样，这是关于就地排序的问题，而不仅仅是一般的排序。

Answer 1

就地Quicksort / InsertionSort / ShellSort实现如何：

public static class InPlaceQuickSort {
    private static void Swap<T>(IList<T> set, int left, int right) {
        T temp = set[left];
        set[left] = set[right];
        set[right] = temp;
    }

    private static Int32 Partition<T>(IList<T> set, int lBound, int rBound)
        where T : IComparable<T> {
        T pivot = set[rBound];
        int left = lBound - 1;
        int right = rBound;

        while (true) {

            while (set[++left].CompareTo(pivot) < 0) ;
            while (set[--right].CompareTo(pivot) > 0) if (left == right) break;

            if (left >= right) break;
            Swap(set, left, right);
        }

        Swap(set, left, rBound);
        return left;
    }

    private static IList<T> QuickSort<T>(IList<T> set, int lBound, int rBound)
        where T : IComparable<T> {
        if (lBound >= rBound) return set;

        Int32 pivot = Partition(set, lBound, rBound);
        QuickSort(set, lBound, pivot - 1);
        QuickSort(set, pivot + 1, rBound);

        return set;
    }

    public static IList<T> InsertionSort<T>(this IList<T> set)
        where T : IComparable<T> {
        for (Int32 index = 1; index < set.Count; index++) {
            for (Int32 insertion = index; insertion > 0 && set[insertion - 1].CompareTo(set[insertion]) > 0; insertion--) {
                Swap(set, insertion - 1, insertion);
            }
        }

        return set;
    }

    public static IList<T> ShellSort<T>(this IList<T> set)
        where T : IComparable<T> {
        Int32 shell = 1;

        while (shell < (set.Count / 3)) shell = shell * 3 + 1;

        while (shell >= 1) {
            for (Int32 index = shell; index < set.Count; index++) {
                for (Int32 insertion = index; insertion >= shell && set[insertion - shell].CompareTo(set[insertion]) > 0; insertion -= shell) {
                    Swap(set, insertion - shell, insertion);
                }
            }

            shell = shell / 3;
        }

        return set;
    }

    public static IList<T> QuickSort<T>(this IList<T> set)
        where T : IComparable<T> {
        return QuickSort<T>(set, 0, set.Count - 1);
    }
}

并且，这是您的用法：

public static void Main() {
    List<Int32> numbers = new List<int> { 1, 3, 2, 4, 2 };

    foreach (Int32 number in numbers.QuickSort())
        Console.WriteLine(number);

    Console.ReadLine();
}

Answer 2

如果您确实需要将其放置在原位，则类似这样的事情应该可以解决问题。

public static class Extensions
{
    public static void InPlaceSort(this IList list)
    {
        var sortedItems = new object[list.Count];
        for (int i = 0; i < list.Count; ++i)
        {
            sortedItems[i] = list[i];
        }
        Array.Sort(sortedItems);
        for (int i = 0; i < list.Count; ++i)
        {
            list[i] = sortedItems[i];
        }
    }
}


IList list = new[] { 3,1,2 };
list.InPlaceSort(); // { 1, 2, 3 }

list = new List<int>(new[] { 4, 2, 3 });
list.InPlaceSort(); // List<int> { 2, 3, 4 }

如果您使用的是IList<T>而不是IList ，则可以保存自己的前几行，然后执行以下操作：

var sortedItems = list.OrderBy(x => x).ToArray();

最后，您仍然需要简单的循环才能将它们放回原始集合中。

Answer 3

否。使用IEnumerable.OrderBy()或SortedList<T>都将创建新的集合。 问题是为什么您不能创建一个新集合？

Answer 4

通过使扩展方法解决方案保持简单并使用.NET的内置排序（还允许自定义IComparer

public static class IListExtensions
{
    public static void Sort<T>(this IList<T> list)
    {
        var orderedList = list.OrderBy(i => i).ToArray();

        for( int i = 0; i < list.Count; ++i )
        {
            list[i] = orderedList[i];
        }
    }

    public static void Sort<T>(this IList<T> list, IComparer<T> comparer )
    {
        var orderedList = list.OrderBy(i => i, comparer).ToArray();

        for (int i = 0; i < list.Count; ++i)
        {
            list[i] = orderedList[i];
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        var orig = new List<int>() { 2, 3, 1 };
        var toOrder = orig;

        Console.Write("Orig: ");
        orig.ForEach(i => Console.Write("{0} ", i));
        toOrder.Sort();
        Console.Write("\nOrdered: ");
        toOrder.ForEach(i => Console.Write("{0} ", i));
        Console.Write("\nOrig: ");
        orig.ForEach(i => Console.Write("{0} ", i));


        Console.ReadLine();
    }

}