(Java)排序算法(二)——冒泡排序(Bubble Sort)

冒泡排序(Bubble Sort)

基本思想

两个数比较大小，较大的数下沉，较小的数冒起来。

简介

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法描述

①比较相邻的元素。如果第一个比第二个大，就交换它们两个；
②对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
③针对所有的元素重复以上的步骤，除了最后一个；
④重复步骤1~3，直到排序完成。

动图演示

代码实现

	/**
	 * 冒泡排序
	 */
	public static int[] bubbleSort(int[] arr){
		if(arr.length > 0){
			//从数组末尾每次减1（排序一次，减少一个数组元素的排序,数组从后到前，从大到小排列）
			for (int i = arr.length - 1; i > 0; i--) {
				//循环，每次循环，最大的数排在最后一位
				for (int j = 0; j < i; j++) {
					//从小到大排序。如果左边大。两个元素交换位置
					if (arr[j] > arr[j + 1]) {
						swap(arr, j, j + 1);
					}
				}
			}
		}
		return arr;
	}

分析

稳定性

冒泡排序是稳定的。因为它是元素两两交换，如果两个元素相等，就不会交换。这样就保证了相同元素的相对位置不变。

时间复杂度

最佳情况：T(n) = O(n) 最差情况：T(n) = O(n^2) 平均情况：T(n) = O(n^2)

因为平均和最差情况下每次遍历这个长度为 n 数组都只能确定一个元素，所以想要确定全部 n 个元素的位置，时间复杂度就为 n×n。但最佳情况下，如果数组是有序的，那么只要遍历一次就够了，所以时间复杂度是 n。

问题——最佳情况T(n) != O(n)

翻阅了很多的博客和资料，都说冒泡排序在最佳情况下（数组本来有序）的时间复杂度是 O(n) ，代码也是如何，几乎差不多，但是我发现无论是怎样的数据状况，都需要执行两层for循环，所以最佳情况应该不是O(n) 才对。
经过多次翻阅博客，查明，原来想要实现冒泡排序T(n) = O(n)，需要在这原有的代码上做出改进。

冒泡排序改进(使最佳情况T(n) = O(n))

思路：当前索引位置开始，若后边元素是有序的，直接返回。在一定程度上，如果数据状况良好，可以降低时间复杂度。

若数组是有序的，只需要经过一次循环，所以最佳情况T(n) = O(n)

	/**
     * 冒泡排序优化——最佳情况T(n) = O(n)
     */
    public static int[] bubbleSort2 ( int[] arr ) {
        if (arr.length > 0) {
            boolean didSwap;
            //从数组末尾每次减1（排序一次，减少一个数组元素的排序）
            for (int i = arr.length - 1; i > 0; i--) {
                didSwap = false;
                //循环，每次循环，最大的数排在最后一位
                for (int j = 0; j < i; j++) {
                    //从小到大排序。如果左边大。两个元素交换位置
                    if (arr[j] > arr[j + 1]) {
                        swap(arr, j, j + 1);
                        didSwap = true;
                    }
                }
                if (!didSwap) {
                    return arr;
                }
            }
        }
        return arr;
    }