c#冒泡排序

需求：将一个无序的数组按从小到大的顺序排列

思想：经过n-1趟比较,第i趟比较（i从0开始）n-i-1次，每次最大的数会排到最后，如果从下往上看就像体积最大的泡泡浮上来，所以叫做冒泡排序。冒泡排序是交换排序的一种

思路：依次比较相邻的两个数,小数放到前面大数放到后面。

实现：

    /// <summary>
    /// 冒泡排序
    /// </summary>
    public class Sort
    {
        /// <summary>
        /// 存放待排序的数组
        /// </summary>
        public int[] arr { get; set; }


        /// <summary>
        /// 冒泡排序
        /// </summary>
        public void BubbleSort()
        {
            if (arr == null)
            {
                throw new ArgumentException("未将排序对象引用设置到实例");
            }


            for (int i = 0; i < arr.Length - 1; i++)
            {
                for (int j = 0; j < arr.Length - i - 1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }

运行结果:

总结：以上冒泡排序的最好和最坏的时间复杂度都为O（n2）;

改进：设定一个标志位，如果某趟排序没有发生数据上的交换，则默认已经是一个有序数组，无须继续

实现：

public void BubbleSortEnhance()
        {
            if (arr == null)
            {
                throw new ArgumentException("未将排序对象引用设置到实例");
            }


            bool swapFlag = true;


            for (int i = 0; i < arr.Length - 1 && swapFlag; i++)
            {
                swapFlag = false;


                for (int j = 0; j < arr.Length - i - 1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;


                        swapFlag = true;
                    }
                }
            }
        }

结果：

比较两次运行结果，可以看出第10趟排序未发生任何交换，所以无需继续执行下去，例子举得不好。

但可以想象出如果一个数组本身是有序的，则只需要经过一趟比较后就能发现，时间复杂度为O（n）。