转载自:http://blog.csdn.net/asd237241291/article/details/8941676
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">无序的数组
- /// <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 name="b">右数组
- /// <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 name="arrange">the value arrange in input array
- /// <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>
- 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 name="StartIndex">
- 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 name="B">
- private void ExchageValue(ref double A, ref double B)
- {
- double Temp = A;
- A = B;
- B = Temp;
- }