经典算法6——冒泡排序

冒泡排序是指，将被排序的记录数组R[1..n]垂直排列，每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡是扫描到违反原则的轻气泡，就使其向上“漂浮”，如此反复进行，直到最后，任何两个气泡都是轻者在上重者在下。
​

活动地址：CSDN21天学习挑战赛

(以上图片来自网络） 

算法分析与改进：

交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序时，第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描完毕时，该区中最轻气泡漂浮到顶部位置R上，结果是R[1..i]变成新的有序区。

时间复杂度与空间复杂度：

最坏情况下，元素初始时逆序排列，此时需执行n-1次，时间复杂度为O(n²)；最好情况下，元素初始时顺序排列，只需要执行一次，时间复杂度为O(n)。

平均时间复杂度为：O(n²)

执行过程未定义新的空间，所以空间复杂度为O(1)

伪代码：

for i = 1 to n-1//执行次数
    change = 0
    for j = n downto i + 1//从后往前遍历
        if A[j] < A[j - 1]
            exchange A[j] with A[j-1]
            change = 1
    if change == 0
        return

Java实现

a[10] = {11,34,20,10,12,35,41,32,43,14}

public class BubbleSort {

    public static void main(String[] args) {
        // input data
        int[] a = {11,34,20,10,12,35,41,32,43,14};
        // 调用冒泡排序
        sort(a);
        // 查看排序结果
        for (int data : a){//foreach语句
            System.out.print(data + "\t");
        }
    }

    private static void sort(int[] a){
        // 外层循环：控制排序的总趟数
        for(int i = 0;i < a.length - 1;i++){
            // 定义变量记录是否发生交换
            int change = 0;
            // 内层循环用于元素的两两比较和交换
            for (int j = a.length - 1;j > i;j--){
                // 如果后面的元素较小，则交换
                if (a[j] < a[j-1]){
                    // 两个元素进行交换
                    int tmp = a[j];
                    a[j] = a[j - 1];
                    a[j - 1] = tmp;
                    // 记录发生了交换
                    change = 1;
                }
            }
            // 如果一次比较中没有发生交换则提前结束
            if (change == 0){
                return;
            }
        }
    }

}

foreach 语法格式如下：

for(元素类型t 元素变量x : 遍历对象obj){
     引用了x的java语句;
}

在以上代码的输出中应用到foreach语句。