数据结构之冒泡排序

冒泡排序（稳定）

算法思想

每一趟排序均从未排序元素开始，将未排序元素与其后边相邻的元素两两比较，若不符合排序要求则两两交换再进行下一个元素与其相邻元素的比较，那么在第一趟排序结束后最大的数到了数组的最后一个元素处，第二趟排序结束后，未排序元素中的最大数来到了倒数第二个元素处。重复以上过程，直到排序结束。

时间复杂度

• 最好情况（待排序数组有序）：O（n）
• 最坏情况：O(n^2)
• 平均复杂度：O(n^2)

实现思路

以arr[7] = {4,3,10,9,2,6,8}为例，从前往后进行升序排序
第一趟排序：对未排序元素区间[0,6]进行排序，未排序区间的下边界为i=6，定义一个索引j指向未排序区间中的元素，j初始指向未排序区间的开始处即j=0。数组为array[7]={4,3,10,9,2,6,8}
开始比较（j<i=6）:
1.j = 0，arr[j] = 4，4比3大故进行交换，数组变为{3,4,10,9,2,6,8}；
2.j++即j = 1，arr[j] = 4,4没有10大故不交换，数组仍为{3,4,10,9,2,6,8}；
3.j++即j = 2，arr[j] = 10,10比9大故进行交换，数组变为{3,4,9,10,2,6,8}；
4.j++即j = 3，arr[j] = 10,10比2大故进行交换，数组变为{3,4,9,2,10,6,8}；
5.j++即j = 4，arr[j] = 10,10比6大故进行交换，数组变为{3,4,9,2,6,10,8}；
6.j++即j = 5，arr[j] = 10,10比8大故进行交换，数组变为{3,4,9,2,6,8,10}；
7.j++即j = 6，j !< i,所以第一趟排序结束，此时未排序区间的最大数10来到了数组的下边界i处。
第二趟排序：对未排序元素区间[0,5]进行排序，未排序区间的下边界为i=5，定义一个索引j指向未排序区间中的元素，j初始指向未排序区间的开始处即j=0。数组为array[7]={3,4,9,2,6,8,10}
开始比较（j<i=5）:
1.j = 0，arr[j] = 3，3没有4大故不交换，数组仍为{3,4,9,2,6,8,10}；
2.j++即j = 1，arr[j] = 4,4没有9大故不交换，数组仍为{3,4,9,2,6,8,10}；
3.j++即j = 2，arr[j] = 9,9比2大故进行交换，数组变为{3,4,2,9,6,8,10}；
4.j++即j = 3，arr[j] = 9,9比6大故进行交换，数组变为{3,4,2,6,9,8,10}；
5.j++即j = 4，arr[j] = 9,9比8大故进行交换，数组变为{3,4,2,6,8,9,10}；
6.j++即j = 5，j !< i,所以第二趟排序结束，此时未排序区间的最大数9来到了数组的下边界i处。
第三趟排序：对未排序元素区间[0,4]进行排序，未排序区间的下边界为i=4，定义一个索引j指向未排序区间中的元素，j初始指向未排序区间的开始处即j=0。数组为array[7]={3,4,2,6,8,9,10}
开始比较（j<i=4）:
1.j = 0，arr[j] = 3，3没有4大故不交换，数组仍为{3,4,2,6,8,9,10}；
2.j++即j = 1，arr[j] = 4,4比2大故进行交换，数组变为{3,2,4,6,8,9,10}；
3.j++即j = 2，arr[j] = 4,4没有6大故不交换，数组仍为{3,2,4,6,8,9,10}；
4.j++即j = 3，arr[j] = 6,6没有8大故不交换，数组仍为{3,2,4,6,8,9,10}；
5.j++即j = 4，j !< i,所以第三趟排序结束，此时未排序区间的最大数8来到了数组的下边界i处。
第四趟排序：对未排序元素区间[0,3]进行排序，未排序区间的下边界为i=3，定义一个索引j指向未排序区间中的元素，j初始指向未排序区间的开始处即j=0。数组为array[7]={3,2,4,6,8,9,10}
开始比较（j<i=3）:
1.j = 0，arr[j] = 3，3比2大故进行交换，数组变为{2,3,4,6,8,9,10}；
2.j++即j = 1，arr[j] = 3,3没有4大故不交换，数组仍为{2,3,4,6,8,9,10}；
3.j++即j = 2，arr[j] = 4,4没有6大故不交换，数组仍为{2,3,4,6,8,9,10}；
4.j++即j = 3，j !< i,所以第四趟排序结束，此时未排序区间的最大数6来到了数组的下边界i处。
第五趟排序：对未排序元素区间[0,2]进行排序，未排序区间的下边界为i=2，定义一个索引j指向未排序区间中的元素，j初始指向未排序区间的开始处即j=0。数组为array[7]={2,3,4,6,8,9,10}
开始比较（j<i=2）:
1.j = 0，arr[j] = 2，2没有3大故不交换，数组仍为{2,3,4,6,8,9,10}；
2.j++即j = 1，arr[j] = 3,3没有4大故不交换，数组仍为{2,3,4,6,8,9,10}；
3.j++即j = 2，j !< i,所以第五趟排序结束，此时未排序区间的最大数4来到了数组的下边界i处。
第六趟排序：对未排序元素区间[0,1]进行排序，未排序区间的下边界为i=1，定义一个索引j指向未排序区间中的元素，j初始指向未排序区间的开始处即j=0。数组为array[7]={2,3,4,6,8,9,10}
开始比较（j<i=1）:
1.j = 0，arr[j] = 2，2没有3大故不交换，数组仍为{2,3,4,6,8,9,10}；
2.j++即j = 1，j !< i,所以第六趟排序结束，此时未排序区间的最大数3来到了数组的下边界i处。
此时未排序区间的元素只剩下一个，所以整个数组有序。

代码实现

/**
 * 冒泡排序
 */
import java.util.Arrays;
public class BubbleSort {
    public static void BubbleSort(int[] arr){
        if(arr.length <= 1){
            return;
        }
        //定义一个i边界，[0,i)表示无序，[i,arr.length)表示有序
        int i = arr.length - 1;
        //排序需要的趟数
        for(;i > 0;i--){
            //每趟排序的比较次数
            for(int j = 0;j < i;j++){
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {4,3,10,9,2,6,8};
        BubbleSort.BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}