大话数据结构 第9章 排序 冒泡排序

  冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

  以int数组为例。

  交换代码：

        public static void Swap(int[] _array, int _indexA, int _indexB)
        {
            int temp = _array[_indexA];
            _array[_indexA] = _array[_indexB];
            _array[_indexB] = temp;
        }

冒泡排序初级版：

        public static void BubbleSort0(int[] _array)
        {
            for (int i = 0; i < _array.Length; i++)
            {
                for (int j = i + 1; j < _array.Length; j++)
                {
                    if (_array[i] > _array[j])
                    {
                        Swap(_array, i, j);
                    }
                }
            }
        }

这段代码严格意义上不算是标准的冒泡排序算法，因为它不满足“两两比较相邻记录”。

这样第一位置的关键字在一次循环后一定变成最小值，再次循环第二个位置的关键字变成最小值...

 这个算法的效率是非常低的。

正宗冒泡排序算法：

        public static void BubbleSort(int[] _array)
        {
            for (int i = 0; i < _array.Length; i++)
            {
                for (int j = _array.Length - 2; j >= i; j--)
                {
                    if (_array[j] > _array[j + 1])
                    {
                        Swap(_array, j, j + 1);
                    }
                }
            }
        }

每次 循环中将一个关键字交换到指定位置，可能还会将一个或多个关键字的位置提升，比之前的算法要有进步。

冒泡排序优化：

循环中没有任何数据交换，这就说明此序列已经有序，不需要再继续后面的循环判断工作了。

        public static void BubbleSortY(int[] _array)
        {
            bool swapFlag = true;
            for (int i = 0; i < _array.Length && swapFlag; i++)
            {
                swapFlag = false;
                for (int j = _array.Length - 2; j >= i; j--)
                {
                    if (_array[j] > _array[j + 1])
                    {
                        Swap(_array, j, j + 1);
                        swapFlag = true;
                    }
                }
            }
        }

冒泡排序复杂度分析：

最好的情况就是要排序的表本身就是有序，根据优化后的代码，就是 n-1 次的比较，没有数据交换，时间复杂度为O(n)  。最坏情况，待排序表是逆序的，此时 需要比较  次，并作等数量级的记录移动，总的时间复杂度为O()。