C#实现所有经典排序算法汇总
C#实现所有经典排序算法
1、选择排序
class SelectionSorter { private int min; public void Sort(int[] arr) { for (int i = 0; i < arr.Length - 1; ++i) { min = i; for (int j = i + 1; j < arr.Length; ++j) { if (arr[j] < arr[min]) min = j; } int t = arr[min]; arr[min] = arr[i]; arr[i] = t; } } }
2、冒泡排序
class EbullitionSorter { public void Sort(int[] arr) { int i, j, temp; bool done = false; j = 1; while ((j < arr.Length) && (!done))//判断长度 { done = true; for (i = 0; i < arr.Length - j; i++) { if (arr[i] > arr[i + 1]) { done = false; temp = arr[i]; arr[i] = arr[i + 1];//交换数据 arr[i + 1] = temp; } } j++; } } }
3、快速排序
class QuickSorter { private void swap(ref int l, ref int r) { int temp; temp = l; l = r; r = temp; } public void Sort(int[] list, int low, int high) { int pivot;//存储分支点 int l, r; int mid; if (high <= low) return; else if (high == low + 1) { if (list[low] > list[high]) swap(ref list[low], ref list[high]); return; } mid = (low + high) >> 1; pivot = list[mid]; swap(ref list[low], ref list[mid]); l = low + 1; r = high; do { while (l <= r && list[l] < pivot) l++; while (list[r] >= pivot) r--; if (l < r) swap(ref list[l], ref list[r]); } while (l < r); list[low] = list[r]; list[r] = pivot; if (low + 1 < r) Sort(list, low, r - 1); if (r + 1 < high) Sort(list, r + 1, high); } }
4、插入排序
public class InsertionSorter { public void Sort(int[] arr) { for (int i = 1; i < arr.Length; i++) { int t = arr[i]; int j = i; while ((j > 0) && (arr[j - 1] > t)) { arr[j] = arr[j - 1];//交换顺序 --j; } arr[j] = t; } } }
5、希尔排序
public class ShellSorter { public void Sort(int[] arr) { int inc; for (inc = 1; inc <= arr.Length / 9; inc = 3 * inc + 1) ; for (; inc > 0; inc /= 3) { for (int i = inc + 1; i <= arr.Length; i += inc) { int t = arr[i - 1]; int j = i; while ((j > inc) && (arr[j - inc - 1] > t)) { arr[j - 1] = arr[j - inc - 1];//交换数据 j -= inc; } arr[j - 1] = t; } } } }
6、归并排序
/// <summary> /// 归并排序之归：归并排序入口 /// </summary> /// <param name="data">无序的数组</param> /// <returns>有序数组</returns> /// <author>Lihua(www.zivsoft.com)</author> int[] Sort(int[] data) { //取数组中间下标 int middle = data.Length / 2; //初始化临时数组let,right，并定义result作为最终有序数组 int[] left = new int[middle], right = new int[middle], result = new int[data.Length]; if (data.Length % 2 != 0)//若数组元素奇数个，重新初始化右临时数组 { right = new int[middle + 1]; } if (data.Length <= 1)//只剩下1 or 0个元数，返回，不排序 { return data; } int i = 0, j = 0; foreach (int x in data)//开始排序 { if (i < middle)//填充左数组 { left[i] = x; i++; } else//填充右数组 { right[j] = x; j++; } } left = Sort(left);//递归左数组 right = Sort(right);//递归右数组 result = Merge(left, right);//开始排序 //this.Write(result);//输出排序,测试用(lihua debug) return result; } /// <summary> /// 归并排序之并:排序在这一步 /// </summary> /// <param name="a">左数组</param> /// <param name="b">右数组</param> /// <returns>合并左右数组排序后返回</returns> int[] Merge(int[] a, int[] b) { //定义结果数组，用来存储最终结果 int[] result = new int[a.Length + b.Length]; int i = 0, j = 0, k = 0; while (i < a.Length && j < b.Length) { if (a[i] < b[j])//左数组中元素小于右数组中元素 { result[k++] = a[i++];//将小的那个放到结果数组 } else//左数组中元素大于右数组中元素 { result[k++] = b[j++];//将小的那个放到结果数组 } } while (i < a.Length)//这里其实是还有左元素，但没有右元素 { result[k++] = a[i++]; } while (j < b.Length)//右右元素，无左元素 { result[k++] = b[j++]; } return result;//返回结果数组 } 注：此算法由周利华提供（http://www.cnblogs.com/architect/archive/2009/05/06/1450489.html ）
7、基数排序
//基数排序 public int[] RadixSort(int[] ArrayToSort, int digit) { //low to high digit for (int k = 1; k <= digit; k++) { //temp array to store the sort result inside digit int[] tmpArray = new int[ArrayToSort.Length]; //temp array for countingsort int[] tmpCountingSortArray = new int[10]{0,0,0,0,0,0,0,0,0,0}; //CountingSort for (int i = 0; i < ArrayToSort.Length; i++) { //split the specified digit from the element int tmpSplitDigit = ArrayToSort[i]/(int)Math.Pow(10,k-1) - (ArrayToSort[i]/(int)Math.Pow(10,k))*10; tmpCountingSortArray[tmpSplitDigit] += 1; } for (int m = 1; m < 10; m++) { tmpCountingSortArray[m] += tmpCountingSortArray[m - 1]; } //output the value to result for (int n = ArrayToSort.Length - 1; n >= 0; n--) { int tmpSplitDigit = ArrayToSort[n] / (int)Math.Pow(10,k - 1) - (ArrayToSort[n]/(int)Math.Pow(10,k)) * 10; tmpArray[tmpCountingSortArray[tmpSplitDigit]-1] = ArrayToSort[n]; tmpCountingSortArray[tmpSplitDigit] -= 1; } //copy the digit-inside sort result to source array for (int p = 0; p < ArrayToSort.Length; p++) { ArrayToSort[p] = tmpArray[p]; } } return ArrayToSort; }
8、计数排序
//计数排序 /// <summary> /// counting sort /// </summary> /// <param name="arrayA">input array</param> /// <param name="arrange">the value arrange in input array</param> /// <returns></returns> public int[] CountingSort(int[] arrayA, int arrange) { //array to store the sorted result, //size is the same with input array. int[] arrayResult = new int[arrayA.Length]; //array to store the direct value in sorting process //include index 0; //size is arrange+1; int[] arrayTemp = new int[arrange+1]; //clear up the temp array for(int i = 0; i <= arrange; i++) { arrayTemp[i] = 0; } //now temp array stores the count of value equal for(int j = 0; j < arrayA.Length; j++) { arrayTemp[arrayA[j]] += 1; } //now temp array stores the count of value lower and equal for(int k = 1; k <= arrange; k++) { arrayTemp[k] += arrayTemp[k - 1]; } //output the value to result for (int m = arrayA.Length-1; m >= 0; m--) { arrayResult[arrayTemp[arrayA[m]] - 1] = arrayA[m]; arrayTemp[arrayA[m]] -= 1; } return arrayResult; }
9、小根堆排序
/// <summary> /// 小根堆排序 /// </summary> /// <param name="dblArray"></param> /// <param name="StartIndex"></param> /// <returns></returns> private void HeapSort(ref double[] dblArray) { for (int i = dblArray.Length - 1; i >= 0; i--) { if (2 * i + 1 < dblArray.Length) { int MinChildrenIndex = 2 * i + 1; //比较左子树和右子树，记录最小值的Index if (2 * i + 2 < dblArray.Length) { if (dblArray[2 * i + 1] > dblArray[2 * i + 2]) MinChildrenIndex = 2 * i + 2; } if (dblArray[i] > dblArray[MinChildrenIndex]) { ExchageValue(ref dblArray[i], ref dblArray[MinChildrenIndex]); NodeSort(ref dblArray, MinChildrenIndex); } } } } /// <summary> /// 节点排序 /// </summary> /// <param name="dblArray"></param> /// <param name="StartIndex"></param> private void NodeSort(ref double[] dblArray, int StartIndex) { while (2 * StartIndex + 1 < dblArray.Length) { int MinChildrenIndex = 2 * StartIndex + 1; if (2 * StartIndex + 2 < dblArray.Length) { if (dblArray[2 * StartIndex + 1] > dblArray[2 * StartIndex + 2]) { MinChildrenIndex = 2 * StartIndex + 2; } } if (dblArray[StartIndex] > dblArray[MinChildrenIndex]) { ExchageValue(ref dblArray[StartIndex], ref dblArray[MinChildrenIndex]); StartIndex = MinChildrenIndex; } } } /// <summary> /// 交换值 /// </summary> /// <param name="A"></param> /// <param name="B"></param> private void ExchageValue(ref double A, ref double B) { double Temp = A; A = B; B = Temp; }
