冒泡排序和改进的冒泡排序的性能差距

若记录序列的初始状态为“正序”，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为“逆序”，则需进行n(n-1)/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。
下面我们编写一个测试程序，随机生成1000组每组为10个元素的数组，对其采用冒泡排序算法和改进的冒泡排序算法分别进行排序。最后我们看一下两种算法之间的差距。测试程序的源代码如下：

using System;
class Program
{
    static void Main(string[] args)
    {
        //冒泡排序 循环总共执行次数
        int BubbleSortCount = 0;
        //改进的冒泡排序 循环总共执行次数
        int ImprovedBubbleSortCount = 0;
        //冒泡排序所需的临时变量
        int temp;
        //一个交错二维数组，用于保存测试数据
        int[][] arr2 = new int[1000][];
        //创建一个随机类，用于生成随机测试数据
        Random r = new Random();
        //通过嵌套的for循环，使用上面的随机数对象生成随机测试数据
        for (int i = 0; i < arr2.Length; i++)
        {
            //新建一个一维数组
            int[] arr = new int[10];
            for (int j = 0; j < arr.Length; j++)
            {
                //通过调用随机类对象 r 的Next方法，随机生成1000以内的测试数据
                arr[j] = r.Next(1000);
            }
            //将包含测试数据的一维数组作为二维数组的元素
            arr2[i] = arr;
        }
        //另外保存一份相同的测试数据，用于测试改进的冒泡排序算法效率
        int[][] ImprovedArr2 = new int[1000][];
        for (int i = 0; i < arr2.Length; i++)
        {
            ImprovedArr2[i] = new int[10];
            arr2[i].CopyTo(ImprovedArr2[i], 0);
        }
        //针对二维数组的每个一维数组元素进行冒泡排序，也就是说测试冒泡排序1000次
        for (int h = 0; h < arr2.Length; h++)
        {
            //冒泡排序
            for (int i = 1; i < arr2[h].Length; i++)
            {
                for (int j = 0; j < arr2[h].Length - 1; j++)
                {
                    if (arr2[h][j] > arr2[h][j + 1])  //将每相邻的两个数相比
                    {
                        temp = arr2[h][j];
                        arr2[h][j] = arr2[h][j + 1];
                        arr2[h][j + 1] = temp;
                    }
                }
                //记录每一轮排序
                BubbleSortCount++;
            }
        }
        Console.WriteLine("对1000个长度为10的随机数组使用【冒泡排序算法】排序总次数：/t" + BubbleSortCount);

        //针对二维数组的每个一维数组元素进行【改进的冒泡排序】，也就是说测试【改进的冒泡排序】1000次
        bool flag = true;
        for (int h = 0; h < ImprovedArr2.Length; h++)
        {
            //使用改进的冒泡排序进行测试
            for (int i = 1; i < ImprovedArr2[h].Length; i++)
            {
                //每轮排序结束后都复位标识位
                flag = true;
                for (int j = 0; j < ImprovedArr2[h].Length - 1; j++)
                {
                    //将每相邻的两个数相比
                    if (ImprovedArr2[h][j] > ImprovedArr2[h][j + 1]) 
                    {
                        temp = ImprovedArr2[h][j];
                        ImprovedArr2[h][j] = ImprovedArr2[h][j + 1];
                        ImprovedArr2[h][j + 1] = temp;

                        flag = false;
                    }
                }
                ImprovedBubbleSortCount++;
                if (flag)
                    break;
            }
        }
        Console.WriteLine("对1000个长度为10的随机数组使用【改进的冒泡排序算法】排序总次数：/t" + ImprovedBubbleSortCount);
    }

 

运行结果：

对1000个长度为10的随机数组使用【冒泡排序算法】排序总次数：      9000
对1000个长度为10的随机数组使用【改进的冒泡排序算法】排序总次数：        7368
请按任意键继续. . .