几种常见的排序算法

private static void Interop_ExchangeValue<T>(ref T m, ref T n)
{
T Temp = m;
m = n;
n = Temp;
}

插入排序

public static void InsertSort<T>(ref T[] array, IComparer<T> comparer)
{
if (array.Length > 0)
{
for (int i = 1; i < array.Length; i++)
{
int front = i - 1;
int index = i;
while (front >= 0)
{
if (comparer.Compare(array[index], array[front]) < 0)
{
Interop_ExchangeValue(ref array[index], ref array[front]);
index = front;
}
front--;
}
}
}
}

选择排序

public static void SelectSort<T>(ref T[] array, IComparer<T> comparer)
{
if (array.Length > 0)
{
for (int i = 0; i < array.Length; i++)
{
T minValue = array[i];
int minIndex = i;
for (int j = i; j < array.Length; j++)
{
if (comparer.Compare(minValue, array[j]) > 0)
{
minValue = array[j];
minIndex = j;
}
}
Interop_ExchangeValue(ref array[i], ref array[minIndex]);
}
}
}

冒泡排序

public static void BubbleSort<T>(ref T[] array, IComparer<T> comparer)
{
if (array.Length > 0)
{
for (int i = 0; i < array.Length - 1; i++)
{
for (int j = array.Length - 1; j > i; j--)
{
if (comparer.Compare(array[j - 1], array[j]) > 0)
{
Interop_ExchangeValue(ref array[j - 1], ref array[j]);
}
}
}
}
}

双向冒泡排序

public static void BidirectionalBubleSort<T>(ref T[] array, IComparer<T> comparer)
{
if (array.Length > 0)
{
int end = array.Length;
int start = -1;
bool swapped = false;
do
{
swapped = false;
start++;
end--;

for (int j = start; j < end; j++)
{
if (comparer.Compare(array[j], array[j + 1]) > 0)
{
Interop_ExchangeValue(ref array[j], ref array[j + 1]);
swapped = true;
}
}
for (int j = end - 1; j >= start; j--)
{
if (comparer.Compare(array[j], array[j + 1]) > 0)
{
Interop_ExchangeValue(ref array[j], ref array[j + 1]);
swapped = true;
}
}
} while (start < end && swapped);
}
}

快速排序

public static void QuickSort<T>(ref T[] array, IComparer<T> comparer)
{
if (array.Length > 0)
{
Interop_QuickSort<T>(ref array, 0, array.Length - 1, comparer);
}
}

private static void Interop_QuickSort<T>(ref T[] array, int left, int right, IComparer<T> comparer)
{
if (left < right)
{
T key = array[(left + right) / 2];
int i = left - 1;
int j = right + 1;
while (true)
{
while (comparer.Compare(array[++i], key) < 0) ;
while (comparer.Compare(array[--j], key) > 0) ;
if (i >= j)
{
break;
}
Interop_ExchangeValue(ref array[i], ref array[j]);
}
Interop_QuickSort(ref array, left, i - 1, comparer);
Interop_QuickSort(ref array, j + 1, right, comparer);
}
}

堆排序

public static void HeapSort<T>(ref T[] array, IComparer<T> comparer)
{
for (int i = (array.Length - 1) / 2; i >= 0; i--)
{
Interop_HeapAdjust(ref array, i, array.Length - 1, comparer);
}
for (int i = array.Length - 1; i >= 1; i--)
{
Interop_ExchangeValue<T>(ref array[0], ref array[i]);
Interop_HeapAdjust(ref array, 0, i - 1, comparer);
}
}

private static void Interop_HeapAdjust<T>(ref T[] array, int index, int length, IComparer<T> comparer)
{
T Temp = array[index];
int j = index * 2 + 1;
while (j <= length)
{
if (j < length)
{
if (comparer.Compare(array[j], array[j + 1]) < 0)
{
j = j + 1;
}
}
if (comparer.Compare(Temp, array[j]) < 0)
{
array[index] = array[j];
index = j;
j = 2 * index + 1;
}
else
{
j = length + 1;
}
}
array[index] = Temp;
}