C#实现所有经典排序算法汇总

C#实现所有经典排序算法
1、选择排序

class SelectionSorter
{
    private int min;
    public void Sort(int[] arr)
    {
        for (int i = ; i < arr.Length - ; ++i)
        {
            min = i;
            for (int j = i + ; 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 = ;
        while ((j < arr.Length) && (!done))//判断长度
        {
            done = true;
            for (i = ; i < arr.Length - j; i++)
            {
                if (arr[i] > arr[i + ])
                {
                    done = false;
                    temp = arr[i];
                    arr[i] = arr[i + ];//交换数据
                    arr[i + ] = 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 + )
        {
            if (list[low] > list[high])
                swap(ref list[low], ref list[high]);
            return;
        }
        mid = (low + high) >> ;
        pivot = list[mid];
        swap(ref list[low], ref list[mid]);
        l = low + ;
        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 +  < r)
            Sort(list, low, r - );
        if (r +  < high)
            Sort(list, r + , high);
    }
}    

4、插入排序

public class InsertionSorter
{
    public void Sort(int[] arr)
    {
        for (int i = ; i < arr.Length; i++)
        {
            int t = arr[i];
            int j = i;
            while ((j > ) && (arr[j - ] > t))
            {
                arr[j] = arr[j - ];//交换顺序
                --j;
            }
            arr[j] = t;
        }
    }
} 

5、希尔排序

public class ShellSorter
{
    public void Sort(int[] arr)
    {
        int inc;
        for (inc = ; inc <= arr.Length / ; inc =  * inc + ) ;
        for (; inc > ; inc /= )
        {
            for (int i = inc + ; i <= arr.Length; i += inc)
            {
                int t = arr[i - ];
                int j = i;
                while ((j > inc) && (arr[j - inc - ] > t))
                {
                    arr[j - ] = arr[j - inc - ];//交换数据
                    j -= inc;
                }
                arr[j - ] = t;
            }
        }
    }
}  

6、归并排序

     /// <summary>
        /// 归并排序之归：归并排序入口
        /// </summary>
        /// <param name="data">无序的数组</param>
        /// <returns>有序数组</returns>
        /// <author>Lihua(www.zivsoft.com)</author>
        int[] Sort(int[] data)
        {
            //取数组中间下标
            int middle = data.Length / ;
            //初始化临时数组let,right，并定义result作为最终有序数组
            int[] left = new int[middle], right = new int[middle], result = new int[data.Length];
            if (data.Length %  != )//若数组元素奇数个，重新初始化右临时数组
            {
                right = new int[middle + ];
            }
            if (data.Length <= )//只剩下1 or 0个元数，返回，不排序
            {
                return data;
            }
            int i = , j = ;
            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 = , j = , k = ;
            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 = ; 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[]{,,,,,,,,,};
                //CountingSort
                for (int i = ; i < ArrayToSort.Length; i++)
                {
                    //split the specified digit from the element
                    int tmpSplitDigit = ArrayToSort[i]/(int)Math.Pow(,k-) - (ArrayToSort[i]/(int)Math.Pow(,k))*;
                    tmpCountingSortArray[tmpSplitDigit] += ;
                }
                for (int m = ; m < ; m++)
                {
                    tmpCountingSortArray[m] += tmpCountingSortArray[m - ];
                }
                //output the value to result
                for (int n = ArrayToSort.Length - ; n >= ; n--)
                {
                    int tmpSplitDigit = ArrayToSort[n] / (int)Math.Pow(,k - ) - (ArrayToSort[n]/(int)Math.Pow(,k)) * ;
                    tmpArray[tmpCountingSortArray[tmpSplitDigit]-] = ArrayToSort[n];
                    tmpCountingSortArray[tmpSplitDigit] -= ;
                }
                //copy the digit-inside sort result to source array
                for (int p = ; 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+];
            //clear up the temp array
            for(int i = ; i <= arrange; i++)
            {
                arrayTemp[i] = ;
            }
            //now temp array stores the count of value equal
            for(int j = ; j < arrayA.Length; j++)
            {
                arrayTemp[arrayA[j]] += ;
            }
            //now temp array stores the count of value lower and equal
            for(int k = ; k <= arrange; k++)
            {
                arrayTemp[k] += arrayTemp[k - ];
            }
            //output the value to result
            for (int m = arrayA.Length-; m >= ; m--)
            {
                arrayResult[arrayTemp[arrayA[m]] - ] = arrayA[m];
                arrayTemp[arrayA[m]] -= ;
            }
            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 - ; i >= ; i--)
            {
                if ( * i +  < dblArray.Length)
                {
                    int MinChildrenIndex =  * i + ;
                    //比较左子树和右子树，记录最小值的Index
                    if ( * i +  < dblArray.Length)
                    {
                        if (dblArray[ * i + ] > dblArray[ * i + ])
                            MinChildrenIndex =  * i + ;
                    }
                    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 ( * StartIndex +  < dblArray.Length)
            {
                int MinChildrenIndex =  * StartIndex + ;
                if ( * StartIndex +  < dblArray.Length)
                {
                    if (dblArray[ * StartIndex + ] > dblArray[ * StartIndex + ])
                    {
                        MinChildrenIndex =  * StartIndex + ;
                    }
                }
                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;
        }