C# 数据结构中 排序算法

//http://www.hiahia.org/datastructure/paixu/paixu8.4.1-1.htm 参考地址

//按平均时间将排序分为四类：

//（1）平方阶(O(n2))排序
//     一般称为简单排序，例如直接插入、直接选择和冒泡排序；

//（2）线性对数阶(O(nlgn))排序
//     如快速、堆和归并排序；

//（3）O(n1+￡)阶排序
//     ￡是介于0和1之间的常数，即0<￡<1，如希尔排序；

//（4）线性阶(O(n))排序
//     如桶、箱和基数排序。

namespace ConsoleApplication1
{
    public class SortOne
    {
        public static void Main()
        {
            int[] t = { 12, 1, 3, 4, 7 };
            //t = InsertSort(t);
            //t = BInsertSort(t);
            //t = BubbleSort1(t);
            //t = BubbleSort2(t);
            //t = QuickSort(t, 0, t.Length - 1);

            //int[] temp = new int[t.Length];
            //t = MergeSort(t, temp, 0, t.Length - 1);
            //t = MergeSort1(t, 0, t.Length - 1);
            t = DirectSort(t);
            for (int i = 0; i < t.Length; i++)
                Console.Write(t[i].ToString() + " ");
            Console.Read();
        }
        #region 插入排序
        //直接插入排序 时间复杂度  O(n^2) 使用附加控件 1 
        //思路：不停的插入，比较之前的数据
        public static int[] InsertSort(int[] T)
        {
            if (T.Length <= 1) return T;
            int temp;
            for (int i = 1; i < T.Length; i++)
            {
                if (T[i] < T[i - 1])
                {
                    temp = T[i];
                    int j;
                    for (j = i - 1; j >= 0 && temp < T[j]; j--)
                    {
                        T[j + 1] = T[j];
                    }
                    T[j + 1] = temp;
                }
            }
            return T;
        }
        //直接插入排序 时间复杂度  O(n^2) 使用附加控件 1 
        //思路：不停的插入比较之前的数据；插入地址用折半查找法定位
        public static int[] BInsertSort(int[] T)
        {
            if (T.Length <= 1) return T;
            int temp;
            for (int i = 1; i < T.Length; i++)
            {
                if (T[i] < T[i - 1])
                {
                    temp = T[i];
                    int low = 0, high = i - 1, m = i - 1; //look for the move-index
                    while (low <= high)
                    {
                        m = (low + high) / 2;
                        if (T[m] > T[i]) high = m - 1;
                        else low = m + 1;
                    }
                    for (int j = i - 1; j >= m && j < T.Length - 1; j--)
                    {
                        T[j + 1] = T[j];
                    }
                    T[m] = temp;
                }
            }
            return T;
        }
        #endregion

        #region  冒泡排序
        //冒泡排序   时间复杂度   O(n^2)  不使用新的空间
        //思路： 逐次比较，轻的冒泡上浮
        public static int[] BubbleSort1(int[] T)
        {
            int Count = T.Length;
            for (int i = 0; i < Count - 1; i++)
            {
                bool exchange = false;
                for (int j = i + 1; j < Count; j++)
                {
                    if (T[i] > T[j])
                    {
                        T[i] ^= T[j];
                        T[j] ^= T[i];
                        T[i] ^= T[j];
                        exchange = true;
                    }
                }
                if (!exchange) return T;
            }
            return T;
        }

        public static int[] BubbleSort2(int[] T)
        {
            int Count = T.Length;
            bool exchange = true;
            while (Count >= 0 && exchange)
            {
                exchange = false;
                for (int i = 0; i < Count - 1; i++)
                {
                    if (T[i] > T[i + 1])
                    {
                        T[i] ^= T[i + 1];
                        T[i + 1] ^= T[i];
                        T[i] ^= T[i + 1];
                        exchange = true;
                    }
                }
                Count--;
            }
            return T;
        }
        #endregion

        #region  希尔排序  缩小增量排序，也属于插入排序的方法 ，时间效益上有较大的改进
        //先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录'基本有序'，再对全体记录进行一次直接插入排序
        private static void ShellInsert(int[] T, int dk)
        {
            int temp;
            //对顺序表L做一趟希尔插入排序，前后记录的位置增量为dk，而不是之前默认的1；相隔dk的比较
            for (int i = dk; i < T.Length; i++)
            {
                if (T[i] > T[i - dk])
                {
                    int j;
                    temp = T[i];
                    for (j = i - dk; j >= 0 && T[j] > T[i]; j -= dk)
                    {
                        T[j + dk] = T[j];
                    }
                    T[j + dk] = temp;
                }
            }
        }
        public static int[] ShellSort(int[] T, int[] dks)
        {//按照dk中的数据进行比较
            for (int k = 0; k < dks.Length; k++)
                ShellInsert(T, dks[k]);//demo：dks 的数据 为： 5，3，1；其中的数据需要猜测计算，最后一个一定为1
            return T;
        }
        #endregion

        #region  快速排序   对冒泡排序的改进
        // 通过一趟排序将待排记录分割成独立的2部分，其中一部分记录的关键字比另一部分的关键字小，则可分别对这2部分继续进行排序，已达到整个序列有序
        //一般默认将T[0]做为 开始的区间轴  pivot;小的关键字放在他之前，反之放在之后，之后定位pivot
        //递归 以pivot为界限的 余下的2个区间
        private static int QuickSortPartition(int[] T, int low, int high) //一次排序，可以将 pivot放在正确的位置，左右子相对有序，左子一定小于右子
        {
            int temp;
            if (low < T.Length)
                temp = T[low];
            else return low - 1; //low index out of range
            while (low < high)
            {
                while (low < high && T[high] > temp)
                    --high;
                T[low] = T[high];
                while (low < high && T[low] < temp)
                    ++low;
                T[high] = T[low];

            }
            T[low] = temp;
            return low;
        }
        public static int[] QuickSort(int[] T, int low, int high) //递归调用
        {
            if (low < high)
            {
                int pLoc = QuickSortPartition(T, low, high);
                QuickSort(T, 0, pLoc - 1);//left
                QuickSort(T, pLoc + 1, high);//right
            }
            return T;
        }
        #endregion

        #region  选择排序
        //每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。
        //n(n-1)/2=0(n2)
        //直接选择排序
        public static int[] DirectSort(int[] T)
        {
            if (T.Length <= 1)
                return T;
            for (int i = 0; i < T.Length; i++)
            {
                int temp = T[i];
                int min=i;
                for ( int k = i; k < T.Length; k++)
                {
                    if (temp >= T[k])
                    {
                        temp = T[k];
                        min = k;
                    }//get the least data in k...n
                }
                T[min] = T[i];
                T[i] = temp;
            }
            return T;
        }
        #endregion

        #region  归并排序
        //设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，
        //先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。
        private static void Merge(int[] T, int[] Temp, int low, int m, int high)
        {
            int start = low;
            int i = low, j = m + 1;
            while (i <= m && j <= high)
            {
                Temp[start++] = T[i] < T[j] ? T[i++] : T[j++];
            }
            while (i <= m)
            {
                Temp[start++] = T[i++];
            }
            while (j <= high)
            {
                Temp[start++] = T[j++];
            }
            while (low <= high)// 合并回去到 数组 T
            {
                T[low] = Temp[low];
                low++;
            }
        }
        public static int[] MergeSort(int[] T, int[] Temp, int low, int high)
        {
            if (low < high)
            {
                int m = (low + high) / 2;
                MergeSort(T, Temp, low, m);
                MergeSort(T, Temp, m + 1, high);
                Merge(T, Temp, low, m, high);
            }
            return T;
        }
        //dynamic malloc array length
        private static void Merge1(int[] T, int low, int m, int high)//内部分配 临时数组大小
        {
            int start = low;
            int i = low, j = m + 1; int p = 0;
            int[] Temp = new int[high - low + 1];
            while (i <= m && j <= high)
            {
                Temp[p++] = T[i] < T[j] ? T[i++] : T[j++];
            }
            while (i <= m)
            {
                Temp[p++] = T[i++];
            }
            while (j <= high)
            {
                Temp[p++] = T[j++];
            }
            for (int index = 0; low <= high; index++)// 合并回去到 数组 T
            {
                T[low] = Temp[index];
                low++;
            }
            Temp = null;
        }

        public static int[] MergeSort1(int[] T, int low, int high)
        {
            if (low < high)
            {
                int m = (low + high) / 2;
                MergeSort1(T, low, m);
                MergeSort1(T, m + 1, high);
                Merge1(T, low, m, high);
            }
            return T;
        }
        #endregion
    }