数据结构与算法--冒泡排序

图解冒泡排序

从图中可知，每一次冒泡都将该次排序中最大的值放到最后适当的位置

需要冒泡的次数 = 数组的长度 - 1

---

排序原理

1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置
2. 对每一对相邻元素做同样的步骤，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值
3. 重复步骤一，直到排序完成

---

代码实现

public void bubbleSort(int[] arr){

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

代码优化

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明该序列有序了，所以在排序过程中设置一个标志 flag 判断元素是否进行过交换，从而减少不必要的比较

public void bubbleSort(int[] arr){

    //设置标记位，减少不必要的循环。即上一次排序后已经是有序的了，就不用进行下一个循环了
    boolean flag;
    for (int i = 0; i < arr.length; i++) {
        flag = false;
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]){
                exchange(arr,j,j + 1);
                flag = true;
            }
        }

        //如果该趟排序没有交换发生，则序列已经有序，退出
        if (!flag) {
            break;
        }
    }
}

public void exchange(int[] arr,int i,int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

---

时间复杂度分析

冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可

在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么

元素比较的次数为：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N²/2-N/2

元素交换的次数为：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N²/2-N/2

总执行次数为：(N²/2-N/2)+(N²/2-N/2)=N²-N

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N²)

---

算法稳定性

只有当arr[j]>arr[j+1]的时候，才会交换元素的位置，而相等的时候并不交换位置，所以冒泡排序是稳定的

算法稳定性：假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的