几种常见的数组排序方法

废话不多说，代码如下，基本的解释也有

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SuanFa
{
    class Program
    {
        private static int min;

        static void Main(string[] args)
        {
            int[] ints = { 2, 8, 22, 88, 9, 6, 2, 7 };
            Sort(ints);
            Print(ints);
            
            int[] ints2 = { 2, 8, 22, 88, 9, 6, 2, 7 };
            SortMaoPao(ints2);
            Print(ints2);

            int[] ints3 = { 2, 8, 22, 88, 9, 6, 2, 7 };
            SortKuaiSu(ints3, 1, 7);
            Print(ints3);

            int[] ints4 = { 2, 8, 22, 88, 9, 6, 2, 7 };
            SortCharu(ints4);
            Print(ints4);

            int[] ints5 = { 2, 8, 22, 88, 9, 6, 2, 7 };
            SortXiEr(ints5);
            Print(ints5);
            int[] ints6 = { 2, 8, 22, 88, 9, 6, 2, 7 };
            Print(SortBingGui(ints6));

            Console.Read();
        }
        public static void Print(int[] ints)
        {
            foreach (int i in ints)
            {
                Console.Write(i + ",");
            }
            Console.WriteLine();
        }
        /// <summary>
        /// 选择排序
        /// </summary>
        /// <param name="arr"></param>
        public static 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;

            }

        }

        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="arr"></param>
        public static void SortMaoPao(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++;
            }
        }


        private static void swap(ref int l, ref int r)
        {
            int temp;
            temp = l;
            l = r;
            r = temp;
        }
        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="list"></param>
        /// <param name="low">起始位置</param>
        /// <param name="high">结束位置</param>
        public static void SortKuaiSu(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)
                SortKuaiSu(list, low, r - 1);
            if (r + 1 < high)
                SortKuaiSu(list, r + 1, high);
        }
        /// <summary>
        /// 插入插叙
        /// </summary>
        /// <param name="arr"></param>
        public static void SortCharu(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;
            }
        }

        /// <summary>
        /// 希尔排序
        /// </summary>
        /// <param name="arr"></param>
        public static void SortXiEr(int[] list)
        {
            int inc;
            for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
            for (; inc > 0; inc /= 3)
            {
                for (int i = inc + 1; i <= list.Length; i += inc)
                {
                    int t = list[i - 1];
                    int j = i;
                    while ((j > inc) && (list[j - inc - 1] > t))
                    {
                        list[j - 1] = list[j - inc - 1];
                        j -= inc;
                    }
                    list[j - 1] = t;
                }
            }

        }
        /// <summary>
        /// 归并排序之归：归并排序入口 
        /// Updated by Lihua at 05/06/2009
        /// </summary>
        /// <param name="data">无序数组</param>
        /// <returns>有序数组</returns>
        /// <author>lihua</author>
        /// <copyright>www.zivsoft.com</copyright>
        static  int[] SortBingGui(int[] data)
        {
            //若data为null，或只剩下1 or 0个元素，返回，不排序
            if (null == data || data.Length <= 1)
            {
                return data;
            }

            //取数组中间下标
            //int middle = data.Length / 2; //方法一：除2取整数
            int middle = data.Length >> 1;  //方法二：位移 (感谢读者hyper给出的这个效率稍高的方法)

            //初始化临时数组let,right，并定义result作为最终有序数组，若数组元素奇数个，将把多余的那元素空间预留在right临时数组
            int[] left = new int[middle], right = new int[data.Length - middle], result = new int[data.Length];

            //下面这句对性能有些影响，所以在上面有了改进，直接用data.Length-middle初始化right数组
            //if (data.Length % 2 != 0) right = new int[middle + 1]; 

            //int i = 0, j = 0;
            //foreach (int x in data)//开始排序
            //{
            //    if (i < middle)//填充左数组
            //    {
            //        left[i] = x;
            //        i++;
            //    }
            //    else//填充右数组
            //    {
            //        right[j] = x;
            //        j++;
            //    }
            //}

            //上面的foreach被改成了for循环
            //for (int i = 0; i < data.Length; i++)
            //{
            //    if (i < middle)//用middle，不用left.Length
            //    {
            //        left[i] = data[i];
            //    }
            //    else
            //    {
            //        right[i - middle] = data[i]; //此处i-middle，让我省掉定义一个j，性能有所提高
            //    }
            //}

            //经调查,用Array.Copy的确比上面的for循环优化很多
            Array.Copy(data, 0, left, 0, middle);//拷贝左数组
            Array.Copy(data, left.Length, right, 0, right.Length); //拷贝右数组

            left = SortBingGui(left);//递归左数组
            right = SortBingGui(right);//递归右数组
            result = Merge(left, right);//开始排序
            //this.Write(result);//输出排序,测试用(lihua debug)
            return result;
        }
        /// <summary>
        /// 归并排序之并:排序在这一步
        /// </summary>
        /// <param name="a">左数组</param>
        /// <param name="b">右数组</param>
        /// <returns>合并左右数组排序后返回</returns>
       static  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;//返回结果数组
        }

    }
}