#region 冒泡排序算法
    //首先将所有待排序的数字放入工作列表中
    //从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换
    //重复2号步骤，直至再也不能交换
    public class BubbleSort
    {
        public void Sort(int[] list)
        {
            int i, j, temp;
            j = 1;
            while (j < list.Length)
            {
                for (i = 0; i < list.Length - j; i++)
                {
                    if (list[i] > list[i + 1])
                    {
                        temp = list[i];
                        list[i] = list[i + 1];
                        list[i + 1] = temp;
                    }
                }
                j++;
            }
        }
    }
    #endregion

    #region  选择排序算法
    //1.设数组内存放了n个待排数字，数组下标从1开始，到n结束
    //2.i=1从数组的第i个元素开始到第n个元素，寻找最小的元素
    //3.将上一步找到的最小元素和第i位元素交换
    //4.如果i=n－1算法结束，否则回到第3步
    public class ChooseSort
    {
        public void Sort(int[] list)
        {
            int min;
            for (int i = 0; i < list.Length - 1; i++)
            {
                min = i;
                for (int j = i + 1; j < list.Length; j++)
                {
                    if (list[j] < list[min])
                        min = j;
                }
                int t = list[min];
                list[min] = list[i];
                list[i] = t;
            }
        }
    }
    #endregion

    #region  插入排序算法
    //首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）
    //从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态
    //重复2号步骤，直至原数列为空
    public class InsertSort
    {
        public void Sort(int[] list)
        {
            for (int i = 1; i < list.Length; ++i)
            {
                int t = list[i];
                int j = i;
                while ((j > 0) && (list[j - 1] > t))
                {
                    list[j] = list[j - 1];
                    --j;
                }
                list[j] = t;
            }
        }
    }
    #endregion

    #region  希尔排序算法
    //先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组
    //所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插入排序
    //然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止
    public class ShellSort
    {
        public void Sort(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;
                }
            }
        }
    }
    #endregion

    #region  快速排序算法
    //实践证明，快速排序是所有排序算法中最高效的一种
    //它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有序了
    //这是一种先进的思想，也是它高效的原因。因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系
    //而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了
    public class QuickSort
    {
        public void Sort(int[] intArray, int nLower, int nUpper)
        {
            if (nLower < nUpper)
            {
                int nSplit = Partition(intArray, nLower, nUpper);
                ///递归排序
                Sort(intArray, nLower, nSplit - 1);
                Sort(intArray, nSplit + 1, nUpper);
            }
        }
        /// <summary>
        /// 方法参数：原始数组、第一个元素位置、最后元素位置
        /// 方法功能：完成一趟快速排序
        /// </summary>
        /// <param name="intArray"></param>
        /// <param name="nLower"></param>
        /// <param name="nUpper"></param>
        /// <returns></returns>
        public int Partition(int[] intArray, int nLower, int nUpper)
        {
            int nLeft = nLower + 1;
            ///以数组第一个元素值作为支点
            int nPivot = intArray[nLower];
            int nRight = nUpper;

            int nSwap;
            while (nLeft <= nRight)
            {
                ///从左向右寻找大于支点元素
                while (nLeft <= nRight && intArray[nLeft] < nPivot)
                    nLeft++;
                ///从右向左寻找小于支点元素
                while (nLeft <= nRight && intArray[nRight] >= nPivot)
                    nRight--;
                ///交换nLeft和nRight位置元素值
                if (nLeft < nRight)
                {
                    nSwap = intArray[nLeft];
                    intArray[nLeft] = intArray[nRight];
                    intArray[nRight] = nSwap;
                    nLeft++;
                    nRight--;
                }
            }
            ///以intArray[nRight]为新支点
            nSwap = intArray[nLower];
            intArray[nLower] = intArray[nRight];
            intArray[nRight] = nSwap;
            return nRight;
        }
    }
    #endregion

     class Program
    {
        static void Main(string[] args)
        {
            int[] iArrary = new int[] { 1, 5, 13, 6, 10, 55, 99, 2, 87, 12, 34, 75, 33, 47 };
            BubbleSort bs = new BubbleSort();  //实例化类
            bs.Sort(iArrary);//排序
            for (int i = 0; i < iArrary.Length; i++)
            {
                Console.WriteLine(iArrary[i]);
            }
        }


     输出结果：