算法笔记(排序算法)

比较常见的比较排序有插入排序，选择排序，冒泡排序，合并排序，快速排序，堆排序等方法，这些排序的期望时间T(n)>O(nlgn).线性排序的方法有计数排序，基数排序，桶排序。排序方法的选择应该考虑几个比较重要的特性：时间复杂度，空间复杂度，稳定性，常数因子，算法实现难度，输入依赖性等。综合这些因素来讲，在实际应用中，线性排序未必就比比较排序要好。
下面是常见的排序实现（计数排序和快速排序可参见前面的博文）:

public class MySort { #region 插入排序 /// <summary> /// 插入排序算法 /// 原地置换：是 /// 平均性能：O(n^2) /// 最好性能O(n)：已符合目标排序； /// 最坏情况O(n^2)：目标排序的倒排； /// </summary> /// <param name="Source">待排数组</param> public static void InsertionSort(int[] Source) { int theLength = Source.Length; //从第2个开始，将当前数插入到0..i-1数组中去. for (int i = 1; i < theLength; i++) { int theCurrVal = Source[i]; int j = i - 1; //找到插入位置，并后移元素. while (j>=0 && theCurrVal < Source[j]) { Source[j + 1] = Source[j]; j--; } Source[j + 1] = theCurrVal; } } #endregion #region 合并排序. /// <summary> /// 归并排序 /// 性能：O(nlog(n))，很稳定，不依赖于输入 /// 原地置换：非原地置换排序，需要O(n)辅助空间. /// 稳定性：稳定的. /// </summary> /// <param name="Source">待排序数组</param> /// <param name="Start">开始位置</param> /// <param name="End">结束位置</param> public static void MergeSort(int[] Source, int Start, int End) { if (Start + 1 == End) { if (Source[Start] > Source[End]) { int theTmp = Source[End]; Source[End] = Source[Start]; Source[Start] = theTmp; } return; } if (Start == End) { return; } int theCenter = (Start + End) / 2; MergeSort(Source, Start, theCenter); MergeSort(Source, theCenter + 1, End); MergeArray(Source, Start, theCenter, theCenter + 1, End); } /// <summary> /// 归并两组. /// </summary> /// <param name="Source">源数组</param> /// <param name="S1">数组1开始索引</param> /// <param name="E1">数组1结束索引</param> /// <param name="S2">数组2开始索引</param> /// <param name="E2">数组2结束索引</param> private static void MergeArray(int[] Source, int S1, int E1, int S2, int E2) { int theLen = E2 - S1 + 1; int[] theTemp = new int[theLen]; int i = S1; int j = S2; int k=0; while (i <= E1 && j <= E2) { if (Source[i] < Source[j]) { theTemp[k] = Source[i]; i++; } else { theTemp[k] = Source[j]; j++; } k++; } while (i <= E1) { theTemp[k] = Source[i]; i++; k++; } while (j <= E2) { theTemp[k] = Source[j]; j++; k++; } for (i = 0; i < theLen; i++) { Source[S1 + i] = theTemp[i]; } } #endregion #region 堆排序 /// <summary> /// 堆排序： /// 平均性能：O(n*lgn)，性能依赖于输入，性能最好是输入倒序排列（最大堆，目标为升序) /// 稳定性：不稳定； /// 原地置换：原地置换排序； /// </summary> /// <param name="A"></param> public static void HeapSort(int[] A) { //建堆O(n) HeapBuilder(A); int theHeapSize = A.Length; //循环取当前堆的最大值,并整理剩余堆 //O(n*lgn) for (int i = A.Length-1; i > 0; i--) { int theTmp = A[0]; A[0] = A[i]; A[i] = theTmp; theHeapSize--; HeapMax(A, 0, theHeapSize); } } /// <summary> /// 取当前节点的左儿子 /// </summary> /// <param name="i">当前节点索引</param> /// <returns>左儿子节点索引</returns> private static int HeapL(int i) { return i * 2 + 1; } /// <summary> /// 取当前节点的右儿子 /// </summary> /// <param name="i">当前节点索引</param> /// <returns>右儿子节点索引</returns> private static int HeapR(int i) { return i * 2 + 2; } /// <summary> /// 取当前节点的父节点索引 /// </summary> /// <param name="i">当前节点索引</param> /// <returns>父节点索引</returns> private static int HeapP(int i) { return (i + 1) / 2 - 1; } /// <summary> /// 向下调整指定节点的，使得当前堆保持最大堆性质。最多调整lgn次. /// </summary> /// <param name="A">要调整的堆数组</param> /// <param name="i">要调整的节点</param> /// <param name="HeapSize">堆大小</param> private static void HeapMax(int[] A, int i, int HeapSize) { int theL = HeapL(i); int theR = HeapR(i); int thelargest = i; if (theL < HeapSize && A[theL] > A[thelargest]) { thelargest = theL; } if (theR < HeapSize && A[theR] > A[thelargest]) { thelargest = theR; } if (thelargest != i) { int theTmp = A[i]; A[i] = A[thelargest]; A[thelargest] = theTmp; HeapMax(A, thelargest, HeapSize); } } /// <summary> /// 构建最大堆 /// </summary> /// <param name="A">待排序数组</param> private static void HeapBuilder(int[] A) { int theHeapSize = A.Length; //满2叉树的性质，内节点数2^(H)-1,外节点数:2^H (H为树的高度) int theP = A.Length / 2 - 1; for (int i = theP; i >= 0; i--) { HeapMax(A,i,theHeapSize); } } #endregion #region 桶排序 /// <summary> /// 桶排序： /// 性能：桶排序的期望时间为O(n),最坏时间为O(n^2).桶排序的性能依赖于输入序列的分布情况 /// 如果重复元素或者分布不均匀的情况下，桶排序就不太适合.另外桶排序需要O(n)额外存储空间。 /// 原地置换：非原地置换排序. /// 稳定性：桶排序的稳定性依赖于桶内排序算法。 /// </summary> /// <param name="A"></param> public static void BucketSort(double[] A) { //double theMax = double.MinValue; //for (int i = 0; i < A.Length; i++) //{ // if (theMax < A[i]) // { // theMax = A[i]; // } //} int theLength = A.Length; //准备桶.O(n) List<List<double>> theBuckets = new List<List<double>>(); for (int i = 0; i < theLength; i++) { theBuckets.Add(new List<double>()); } //分桶O(n) for (int i = 0; i < theLength; i++) { int theIndex =Convert.ToInt32(Math.Floor(A[i] * theLength)); theBuckets[theIndex].Add(A[i]); } //桶内排序期望：O(n)，如果分布均衡，则每个桶的元素都在个位数的情况下， //总的桶内排序时间可认为是线性的。 for (int i = 0; i < theLength; i++) { InsertionSort(theBuckets[i]); } //桶合并.O(n) int theCurrIndex = 0; for (int i = 0; i < theLength; i++) { for (int j = 0; j < theBuckets[i].Count; j++) { A[theCurrIndex] = theBuckets[i][j]; theCurrIndex++; } theBuckets[i].Clear(); } theBuckets.Clear(); } /// <summary> /// 插入排序算法,原地置换排序,O(n^2) /// </summary> /// <param name="Source">待排数组</param> private static void InsertionSort(List<double> Source) { int theLength = Source.Count; //从第2个开始，将当前数插入到0..i-1数组中去. for (int i = 1; i < theLength; i++) { double theCurrVal = Source[i]; int j = i - 1; //找到插入位置，并后移元素. while (j >= 0 && theCurrVal < Source[j]) { Source[j + 1] = Source[j]; j--; } Source[j + 1] = theCurrVal; } } #endregion }