你知道C# 各种排序的编写及性能吗？

 

复习了一下C# 的数据结构的排序算法，其中主要有冒泡排序，直接插入排序，简单选择排序和快速排序，在其中参考了老赵的CodeTimer和eaglet的性能计数器 ，特此感谢~~

好了  开始我们的排序算法吧 ~

在进行排序算法之前，我们先定义一个100位的随机数列，好进行各种排序算法的性能测试。

代码如下：

 

        /// <summary>
        /// 随机生成100位的数组
         /// </summary>
        /// <returns>返回生成数组</returns>
        public static int[] RandomArray()
        {
            Random ran = new Random();
            int[] arr = new int[100];
            int tem;
            for (int i = 0; i < 100; i++)
            {
                tem = ran.Next(1, 100);
                arr[i] = tem;
            }
            return arr;
        }

 

1.   冒泡排序 （Bubble Sort）

基础思想：将相邻的记录的关键码进行比较，若前面记录的关键码大于后面记录的关键码，则将它们交换，否则不交换。

代码如下：

 

    /// <summary>
    /// 冒泡排序算法
    /// </summary>
    public class BubbleSort : IAction
    {
        #region IAction 成员
        public void Action()
        {
            int[] array = Program.RandomArray();
            for (int a = 0; a < array.Length; a++)
            {
                int item = 0;
                for (int b = array.Length - 1; b > a; b--)
                {
                    if (array[b] < array[b - 1])
                    {
                        item = array[b];
                        array[b] = array[b - 1];
                        array[b - 1] = item;
                    }
                }
            }
        }
        #endregion
    }

 

 

2.   直接插入排序

基础思想： 顺序的将待排序的记录安关键码的大小插入到已排序的记录子序列的适当位置。子序列的记录个数从1开始逐渐增大，当子序列记录个数于首先表中的记录个数相同时排序完毕。

代码如下： 

 

    /// <summary>
    /// 直接插入排序算法
    /// </summary>
    public class DirectInsertSort : IAction
    {

        #region IAction 成员

        public void Action()
        {
            int[] array = Program.RandomArray();
            for (int i = 1; i < array.Length; i++)
            {
                if (array[i] < array[i - 1])
                {
                    int tem = array[i];
                    int j = 0;
                    for (j = i - 1; j >= 0 && tem < array[j]; j--)
                    {
                        array[j + 1] = array[j];
                    }
                    array[j + 1] = tem;
                }
            }
        }
        #endregion
    }

 

3.   简单选择排序

基础思想：从待排序的记录序列中选择关键码最小（或）最大的记录并将它也序列中的第一个记录交换位置；然后从不包括第一个位置上的记录序列中选择关键码最小（或最大）的记录并将它也序列中的第2个记录交换位置，如此重复，直到序列只剩下一个记录为止。

代码如下：

 

    /// <summary>
    /// 简单选择排序算法
    /// </summary>
    public class SimpleSelectSort : IAction
    {
        #region IAction 成员
        public void Action()
        {
            int[] array = Program.RandomArray();
                int tmp = 0;
                int t = 0;
                for (int i = 0; i < array.Length; i++)
                {
                    t = i;
                    for (int j = i + 1; j < array.Length; j++)
                    {
                        if (array[t] > array[j])
                        {
                            t = j;
                        }
                    }
                    tmp = array[i];
                    array[i] = array[t];
                    array[t] = tmp;
        }
        #endregion
    }

 

4.   快速排序

基础思想：通过不断比较关键码，以某咯记录为界（该记录成为支点），将待排序列分成两部分。其中，一小部分满足所有记录的关键码都大于或等于支点记录为界将待排序列按关键码中分成两部分的过程，称为一次划分，直到整个序列按关键码有序为止。

代码如下：

 

    /// <summary>
    /// 快速排序算法
    /// </summary>
    public class QuickSort : IAction
    {

        #region IAction 成员

        public void Action()
        {
            int[] array = Program.RandomArray();
            
            QuickSortArray(array, 0, array.Length - 1);
        }

        private void QuickSortArray(int[] arr, int low, int high)
        {
            int i = low;
            int j = high;
            int tmp = arr[low];
            while (low < high)
            {
                while ((low < high) && arr[high] >= tmp)
                {
                    --high;
                }
                arr[low] = arr[high];
                while ((low < high) && arr[low] <= tmp)
                {
                    ++low;
                }
                arr[high] = arr[low];
                --high;
            }
            arr[low] = tmp;
            if (i < low - 1)
            {
                QuickSortArray(arr, i, low - 1);
            }
            if (j > low + 1)
            {
                QuickSortArray(arr, low + 1, j);
            }
        }

        #endregion
    }

 

通过上面的描述，我们对C#几个主要的排序算法了解清楚了 接下来开始解析它们其中的奥妙吧。其实在此之前 我一直都喜欢使用冒泡来排序，不过通过CodeTimer测试了下  结果如下：

 

 

总结：从C#几个常用的排序算法中，我们常用的冒泡法消耗的系统时间是最多了，相比之下快速排序所用的时间倒是很快速。

 

     希望能和大家一起探讨.NET中的神奇，享受编程给我们带来的乐趣~