排序算法之冒泡排序

冒泡排序需要遍历几次数组。在每次遍历中，比较连续相邻的元素。如果某一对元素是降序，则互换他们的值，否则保持不变。一次遍历，至最后一次时，所有元素已经排好顺序

伪算法如下：

for (int k = 1; k < list.length; k++) {
			for (int i = 0; i < args.length - k; i++) {
				if (list[i] > list [i + 1]) {
					swap list[i] with list[i+1];
				}
			}
		}

 恩恩，问题解决了，解决了？好像是，但不是最优雅的方法哦！我们得要力争做一个优雅的程序员

优化思路如下：

//是否需要进行下次遍历
boolean needNextPass = true;
for (int k = 1; k < list.length && needNextPass; k++) {
    needNextPass = false;
    for (int i = 0; i < args.length - k; i++) {
        if (list[i] > list [i + 1]) {
        swap list[i] with list[i+1];
        needNextPass = true;
        }
    }
    }
}

其实就是：如果某次遍历，元素的位置没有更换的时候，就不需要进行下次，因为元素已经站好队了

举个实例：

//Bubble sort instance
public class BubbleSort {
    //Bubble sort method
    public static void bubbleSort(int[] list) {
        boolean needNextPass = true;
        for (int k = 1; k < list.length; k++) {
            needNextPass = false;
            for (int i = 0; i < list.length - k; i++) {
                if (list[i] > list[i+1]) {
                    int temp = list[i];
                    list[i] = list[i+1];
                    list[i+1] = temp;
                    needNextPass = true;
                }
            }
        }
    }
    //Main method
    public static void main(String[] args) {
        int[] list = {2,1,43,6,-3,33,10};
        bubbleSort(list);
        for (int i = 0; i < list.length; i++) {
            System.out.print(list[i] + " ");
        }
    }
}

运行结果：

-3 1 2 6 10 33 43 

 分析冒泡排序的时间：

最好的情况为遍历一次，确定数组已经排好，不需要进行下次遍历。由于第一次遍历的比较次数为n - 1，所有在最好的情况下，冒泡排序的时间为O(n)。

在最差的情况下，冒泡排序的算法需要进行n-1次遍历（倒序）。第一次遍历比较次数为n-1,第二次遍历需要比较n-2，一次类推，则比较的总次数为:(n-1)+(n-2)+...+2+1 = (n-1)n/2=O(n*n),所以最差情况下为O(n*n)，平均时间复杂度为O(n*n)