Array.Sort()实现细节和效率
Array.Sort有N个重载，都是调用同一个方法实现排序（Array.Sort<T>先不管）
public static void Sort(Array keys, Array items, int index, int length, IComparer comparer)
{
// 省略一堆参数检查代码
if ((length > 1) && (((comparer != Comparer.Default) && (comparer != null)) || !TrySZSort(keys, items, index, (index + length) - 1)))
{
object[] objArray = keys as object[];
object[] objArray2 = null;
if (objArray != null)
{
objArray2 = items as object[];
}
if ((objArray != null) && ((items == null) || (objArray2 != null)))
{
new SorterObjectArray(objArray, objArray2, comparer).QuickSort(index, (index + length) - 1);
}
else
{
new SorterGenericArray(keys, items, comparer).QuickSort(index, (index + length) - 1);
}
}
}
其中跟排序有关的代码有三处SorterObjectArray和SorterGenericArray都是Array的内部类，还有个是TrySZSort方法。
TrySZSort方法从签名来看应该是调用外部非托管的代码。
[MethodImpl(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)] private static extern bool TrySZSort(Array keys, Array items, int left, int right);
也就是说，当没有自定义的Comparer对象时，Array优先尝试调用非托管代码对数组进行排序。
接下来看看SorterGenericArray和SorterObjectArray的唯一区别：
SorterObjectArray中直接使用Array.GetValue()/Array.SetValue()对数组进行读写；
SorterGenericArray中则通过Array[]索引器对数组进行读写。
Array[]索引器是怎样的呢，先看看Array里索引器的实现代码：
object IList.this[int index]
{
get
{
return this.GetValue(index);
}
set
{
this.SetValue(value, index);
}
}
Array索引器都是通过Array.GetValue()/Array.SetValue()对数组进行读写的，为什么SorterGenericArray还多此一举呢？
应当注意的是，这里的索引器是显式IList接口的索引器的实现方法，并不是Array[]索引器的实现方法，对于泛型，情况则不一样：
IList<T>泛型接口的定义如下：
public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
{
// ...
T this[int index] { get; set; }
}
IList<T>并不实现IList接口，而是自定义了一个强类型的索引器。
再来看看List<T>泛型类的定义，List实现了List和IList<T>两种接口：
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
List<T>索引器的实现代码：
object IList.this[int index]
{
get
{
return this[index];
}
set
{
List<T>.VerifyValueType(value);
this[index] = (T) value;
}
}
public T this[int index]
{
get
{
if (index >= this._size)
{
ThrowHelper.ThrowArgumentOutOfRangeException();
}
return this._items[index];
}
set
{
if (index >= this._size)
{
ThrowHelper.ThrowArgumentOutOfRangeException();
}
this._items[index] = value;
this._version++;
}
}
注意List<T>的代码在实现IList的索引器时是用显示接口声明的，但IList<T>则没有显式写明接口，于是：
List<int> list = new List<int>(10); list[0]; //这里调用的是IList<int>.this[int]索引器，返回的是int类型 ((IList)list)[0]; //这里调用的是IList.this[int]索引器，返回的是object类型
值得注意的是Array.Sort()接受的是一个Array对象
List<int> myList = new List<int>(); Array.Sort(myList); // 编译错误：参数类型不匹配 Array.Sort<int>(myList); // 编译错误：注意Array.Sort<T>接受参数的是T[]数组
其实对于泛型，使用myList.Sort()就可以了(List<T>.Sort<T>实际还是调用了Array.Sort<T>方法，把内部管理的强类型数组传了过去)
现在回来看Array.Sort方法，既然Array只接受Array对象，为什么还要弄一个SorterGenericArray出来呢?
我们可以注意到只有当keys或者items(item为null时除外)不能转换成一个数组时(items)，才会使用SorterGenericArray.QuickSort进行排序
有时候会给泛型类型增加一个显示/隐式类型转换，把一个泛型类型转化成一个Array数组(并不是调用ToArray哟)，在这种情况下，还是可以调用Array.Sort方法的，如果这时候把这种数组交给SorterObjectArray排序，就可能有两个问题：一是泛型的强类型无法保证，二是IComparer.CompareTo调用时也会有类型问题，所以这里引入了SorterGenericArray类专门处理这类情况，毫无疑问，多了一重类型检查，排序效率相对会低点，可以在下面测试中看出来。于是有了下面的对比测试：
A.把SorterGenericArray代码提取出来，去除所有try等异常检查，作为MySorterWithComparer类主要代码进行排序
B.将A的所有GetValue/SetValue直接使用强类型索引器，并使用<和>操作符代替所有Comparer，作为MySorterWithIntArray类主要代码进行排序
C.Array.Sort()
D.Array.Sort<int>()
E.List<int>.Sort<int>()排序
对长度分别为100/500/1000/10000/10000的int型数组进行排序，发现以下情况：
1. 无论任何情况，使用Comparer和Array.GetValue()/Array.SetValue()效率都很低
2. Array.Sort()/Array.Sort<int>()/List<int>.Sort<int>()性能十分接近
3. 数组长度较小的情况下直接调用Array.Sort的效率比MySorterWithIntArray代码高很多
4. 数组长度超过1000后，MySorterWithIntArray排序比直接调用Array.Sort()效率高一点点
上面现象说明：
1. SorterGenericArray.QuickSort的实现是比较低效的
2. 或许是因为Array是定义在mscorlib中的，MySorterWithIntArray的代码则是在自己生成的程序集中，排序时使用了mscorlib程序集的类和方法。在数组长度较小的情况下，可能由于跨程序集调用的开销比实际排序的开销要大，所以没有直接调用Array.Sort高效。另外一个可能的原因是Array.Sort调用了非托管的代码。
3. 数组长度达到一定规模后，跨程序集调用的开销跟实际排序的开销比已经微乎其微，这时频繁的异常检查(Array.Sort内部有个try...catch)的开销逐渐显现。
其实就算数组比较大(>10w)，MySorterWithIntArray花费的时间也只是比Array.Sort快了不到10%，总体上来说，使用Array.Sort还是一种高效方便的排序方法。
回想现在公司的笔试题，还考啥老掉牙的冒泡排序，事实就是.Net自带的快速排序函数已经非常高效，.Net程序员考排序这种事还是少来吧。
下面是测试记录(Release+代码优化版本，数据很接近，这里不重复了)：
Array Size: 100
Measure Name: MySorterWithComparer.QuickSort
Time Elapsed: 3ms
CPU Cycles: 4,662,548
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: MySorterWithIntArray.QuickSort
Time Elapsed: 1ms
CPU Cycles: 1,856,063
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort
Time Elapsed: 0ms
CPU Cycles: 29,953
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort<int>
Time Elapsed: 0ms
CPU Cycles: 29,084
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: List.Sort
Time Elapsed: 0ms
CPU Cycles: 24,893
Gen 0: 0
Gen 1: 0
Gen 2: 0
Array Size: 500
Measure Name: MySorterWithComparer.QuickSort
Time Elapsed: 3ms
CPU Cycles: 6,358,979
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: MySorterWithIntArray.QuickSort
Time Elapsed: 0ms
CPU Cycles: 103,741
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort
Time Elapsed: 0ms
CPU Cycles: 119,614
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort<int>
Time Elapsed: 0ms
CPU Cycles: 122,639
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: List.Sort
Time Elapsed: 0ms
CPU Cycles: 118,514
Gen 0: 0
Gen 1: 0
Gen 2: 0
Array Size: 1000
Measure Name: MySorterWithComparer.QuickSort
Time Elapsed: 8ms
CPU Cycles: 14,291,893
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: MySorterWithIntArray.QuickSort
Time Elapsed: 0ms
CPU Cycles: 201,663
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort
Time Elapsed: 0ms
CPU Cycles: 251,647
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort<int>
Time Elapsed: 0ms
CPU Cycles: 248,611
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: List.Sort
Time Elapsed: 0ms
CPU Cycles: 236,148
Gen 0: 0
Gen 1: 0
Gen 2: 0
Array Size: 10000
Measure Name: MySorterWithComparer.QuickSort
Time Elapsed: 108ms
CPU Cycles: 180,057,306
Gen 0: 3
Gen 1: 0
Gen 2: 0
Measure Name: MySorterWithIntArray.QuickSort
Time Elapsed: 1ms
CPU Cycles: 2,456,267
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort
Time Elapsed: 1ms
CPU Cycles: 2,663,441
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort<int>
Time Elapsed: 1ms
CPU Cycles: 2,671,900
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: List.Sort
Time Elapsed: 1ms
CPU Cycles: 2,683,780
Gen 0: 0
Gen 1: 0
Gen 2: 0
Array Size: 100000
Measure Name: MySorterWithComparer.QuickSort
Time Elapsed: 1,224ms
CPU Cycles: 2,174,465,964
Gen 0: 39
Gen 1: 0
Gen 2: 0
Measure Name: MySorterWithIntArray.QuickSort
Time Elapsed: 15ms
CPU Cycles: 28,609,746
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort
Time Elapsed: 17ms
CPU Cycles: 30,748,663
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: Array.Sort<int>
Time Elapsed: 17ms
CPU Cycles: 30,883,336
Gen 0: 0
Gen 1: 0
Gen 2: 0
Measure Name: List.Sort
Time Elapsed: 17ms
CPU Cycles: 30,843,142
Gen 0: 0
Gen 1: 0
Gen 2: 0
测试代码：
namespace Just4Test.SortTest
{
class SortTestCode
{
static void Main(string[] args)
{
TestSort(100);
TestSort(500);
TestSort(1000);
TestSort(10000);
TestSort(100000);
}
static int[] GenerateArray(int count)
{
Random rnd = new Random();
int[] array = new int[count];
for (int i = 0; i < count; i++)
{
array[i] = rnd.Next(int.MinValue, int.MaxValue);
}
return array;
}
static void TestSort(int count)
{
Console.WriteLine("Array Size: " + count.ToString());
int[] src = GenerateArray(count);
MySorterWithComparer arr1 = new MySorterWithComparer((int[])(src.Clone()));
MySorterWithIntArray arr2 = new MySorterWithIntArray((int[])(src.Clone()));
int[] arr3 = (int[])(src.Clone());
int[] arr4 = (int[])(src.Clone());
List<int> list = new List<int>((int[])(src.Clone()));
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
CodeTimer.BeginMeasure("MySorterWithComparer.QuickSort");
arr1.QuickSort(0, count - 1);
CodeTimer.EndMeasure();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
CodeTimer.BeginMeasure("MySorterWithIntArray.QuickSort");
arr2.QuickSort(0, count - 1);
CodeTimer.EndMeasure();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
CodeTimer.BeginMeasure("Array.Sort");
Array.Sort(arr3);
CodeTimer.EndMeasure();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
CodeTimer.BeginMeasure("Array.Sort<int>");
Array.Sort<int>(arr4);
CodeTimer.EndMeasure();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
CodeTimer.BeginMeasure("List.Sort");
list.Sort();
CodeTimer.EndMeasure();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
}
}
class MySorterWithComparer
{
private Array array;
private IComparer comparer;
internal MySorterWithComparer(Array array)
{
this.array = array;
this.comparer = Comparer.Default;
}
internal void SwapIfGreaterWithItems(int a, int b)
{
if (a != b)
{
if (this.comparer.Compare(this.array.GetValue(a), this.array.GetValue(b)) > 0)
{
object obj2 = this.array.GetValue(a);
this.array.SetValue(this.array.GetValue(b), a);
this.array.SetValue(obj2, b);
}
}
}
internal void QuickSort(int left, int right)
{
do
{
int low = left;
int hi = right;
int median = (low + ((hi - low) >> 1));
this.SwapIfGreaterWithItems(low, median);
this.SwapIfGreaterWithItems(low, hi);
this.SwapIfGreaterWithItems(median, hi);
object y = this.array.GetValue(median);
do
{
while (this.comparer.Compare(this.array.GetValue(low), y) < 0)
{
low++;
}
while (this.comparer.Compare(y, this.array.GetValue(hi)) < 0)
{
hi--;
}
if (low > hi)
{
break;
}
if (low < hi)
{
object obj3 = this.array.GetValue(low);
this.array.SetValue(this.array.GetValue(hi), low);
this.array.SetValue(obj3, hi);
}
if (low != 0x7fffffff)
{
low++;
}
if (hi != -2147483648)
{
hi--;
}
}
while (low <= hi);
if ((hi - left) <= (right - low))
{
if (left < hi)
{
this.QuickSort(left, hi);
}
left = low;
}
else
{
if (low < right)
{
this.QuickSort(low, right);
}
right = hi;
}
}
while (left < right);
}
}
class MySorterWithIntArray
{
private int[] array;
internal MySorterWithIntArray(int[] array)
{
this.array = array;
}
internal void SwapIfGreaterWithItems(int a, int b)
{
if (a != b && array[a] > array[b])
{
int c = array[a];
array[a] = array[b];
array[b] = c;
}
}
internal void QuickSort(int left, int right)
{
do
{
int low = left;
int high = right;
int median = (low + ((high - low) >> 1));
SwapIfGreaterWithItems(low, median);
SwapIfGreaterWithItems(low, high);
SwapIfGreaterWithItems(median, high);
int y = array[median];
do
{
while (array[low] < y) low++;
while (y < array[high]) high--;
if (low > high) break;
if (low < high)
{
int tmp = array[low];
array[low] = array[low];
array[high] = tmp;
}
low++;
high--;
}
while (low <= high);
if ((high - left) <= (right - low))
{
if (left < high) QuickSort(left, high);
left = low;
}
else
{
if (low < right) QuickSort(low, right);
right = high;
}
}
while (left < right);
}
}
}