几种排序算法

   static void Main(string[] args)
        {
            int[] intArray = { 7, 5, 3, 4, 1, 6, 2, 9, 8, 0 ,12,14,43,44,13,16,15};
            QuickSort(intArray);
            for (int i = 0; i < intArray.Length; i++)
            {
                Console.WriteLine(intArray[i]);
            }
            Console.ReadKey();
        }
        #region 选择排序
        public static void SelectSort(IList<int> data)
        {
            for (int i = 0; i < data.Count - 1; i++)
            {
                int temp = data[i];
                int min = i;
                //每次一个内循环选出一个最小的
                for (int j = i + 1; j < data.Count; j++)
                {
                    if (data[j] > temp)
                    {
                        min = j;
                        temp = data[j];
                    }
                }
                //将这个内循环选出的最小的放在前面
                if (min != i)
                {
                    Swap(data, min, i);
                }
            }
        }
        /// <summary>
        /// 交换数据
        /// </summary>
        /// <param name="data"></param>
        /// <param name="min"></param>
        /// <param name="i"></param>
        private static void Swap(IList<int> data, int min, int i)
        {
            int temp;
            temp = data[min];
            data[min] = data[i];
            data[i] = temp;
        }

        #endregion

        #region 冒泡排序
        public static void BubbleSort(IList<int> data)
        {
            for (int i = data.Count-1; i >0 ; i--)
            {
                for (int j = 0; j < i; j++)
                {
                    if (data[i]>data[j])
                    {
                        Swap(data,i,j);     
                    }
                }
            }
        }
        #endregion

        #region 鸡尾酒排序
        public static void BubbleCocktailSort(IList<int> data)
        {
            //需要来回a,length/2趟
            for (int i = 0; i < data.Count/2; i++)
            {
                //类冒泡，交换最大值至右端
                for (int j  = i; j+1 < data.Count-i ; j++)
                {
                    if (data[j]>data[j+1])
                    {
                        Swap(data,j,j+1);
                    }
                }
                //类冒泡，交换最小值至左端
                for (int m = data.Count-1-i; m >i; m--)
                {
                    if (data[m - 1] > data[m])
                    {
                        Swap(data, m, m - 1);
                    }
                }
            }
        }
        #endregion

        #region 插入排序
        
       
        public static void insertionSort(IList<int> data)
        {
            for (int i = 1; i < data.Count; i++)
            {
                if (data[i]<data[i-1])
                {
                    int temp=data[i];
                    int j;
                    //执行到此步骤时，data[i]之前的都已经完成了排序,将data[i]插入到一个合适的位置
                    for (  j=i ; j>0 && data[j-1]>temp ;   j--)
                    {
                        data[j] = data[j - 1];
                      
                    }
                    data[j] = temp;

                }
            }
        }
        #endregion

        #region 快速排序
        public static void QuickSort(int[] numbers)
        {
            //Sort(numbers, 0, numbers.Length - 1);
            quick_sort(numbers, 0, numbers.Length-1);
        }

        private static void Sort(int[] numbers, int left, int right)
        {
            if (left < right)
            {
                int middle = numbers[(left + right) / 2];
                int i = left - 1;
                int j = right + 1;
                while (true)
                {
                    while (numbers[++i] < middle) ;

                    while (numbers[--j] > middle) ;

                    if (i >= j)
                        break;

                    Swap(numbers, i, j);
                }

                Sort(numbers, left, i - 1);
                Sort(numbers, j + 1, right);
            }
        }
        #endregion