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排序更好用一些,使用简单,主要是不用自己写排序算法。