C#中常见排序方法

C#中常见排序方法

快速排序、堆排序、C#的list自带Sort方法排序、Linq、List自带OrderBy排序

---

快速排序

快排代码。1000万int数据，大约3-4秒。在Unity中大概1-2秒，奇怪。

void QuickSort<T>(T[] a, int l, int r) where T : IComparable
{
   if (l < r)
   {
       int i = l, j = r;
       T pivot = a[i];
       while (i < j)
       {
           while (i < j && a[j].CompareTo(pivot) > 0) j--;
           if (i < j) a[i++] = a[j];

           while (i < j && a[i].CompareTo(pivot) < 0) i++;
           if (i < j) a[j--] = a[i];
       }

       a[i] = pivot;

       QuickSort<T>(a, l, i - 1);
       QuickSort<T>(a, i + 1, r);
   }
}

堆排序

堆排代码。1000万 int 数据大约11秒

/// <summary>
/// 堆排序
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="a"></param>
/// <param name="size">对大小(节点数)</param>
void HeapSort<T>(T[] a, int size) where T : IComparable
{
    /// 初始化堆
    for (int i = size / 2 -1; i >= 0; i--)
    {
        AdjustHeap<T>(a, i, size);
    }

    for (int i = size - 1; i >= 0; i--)
    {
        T tmp = a[0];
        a[0] = a[i];
        a[i] = tmp;

        AdjustHeap<T>(a, 0, i);
    }
}

/// <summary>
/// 调整堆
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="a"></param>
/// <param name="node">调整的节点</param>
/// <param name="size">堆的大小</param>
void AdjustHeap<T>(T[] a, int node, int size) where T : IComparable
{
    if (node > size / 2 - 1)
    {
        return;
    }

    int lchild = node * 2 + 1;
    int rchild = node * 2 + 2;
    int max = node;

    if (lchild <= size - 1 && a[lchild].CompareTo(a[max]) > 0) max = lchild;
    if (rchild <= size - 1 && a[rchild].CompareTo(a[max]) > 0) max = rchild;

    if (max != node)
    {
        T tmp = a[max];
        a[max] = a[node];
        a[node] = tmp;

        /// 调整Max节点
        AdjustHeap<T>(a, max,size);
    }
}

C#的list自带Sort方法排序

C#的list自带Sort方法排序。1000万int数据，大约4-5秒

T[] ListSort<T>(List<T> source) where T: IComparable
{
    source.Sort((a, b) => a.CompareTo(b));
    return source.ToArray();
}

Linq

Linq。1000万int数据，大约5-6秒

T[] LinqSort<T>(List<T> source)
{
    return (from a in source orderby a select a).ToArray();
}

List自带OrderBy排序

List自带OrderBy排序。1000万int数据，大约5-6秒

T[] ListOrderBy<T>(List<T> source)
{
    return source.OrderBy(a => a).ToArray();
}

总结

快速排序貌似还是相当快的，但是貌似List自带的Sort排序更好用一些，使用简单，主要是不用自己写排序算法。