排序系列【比较排序系列之】冒泡排序

冒泡排序属于交换排序的一种典型的交换排序。交换排序的基本思想是：两两比较待排序的关键码，发现记录逆置则进行交换，知道没有逆置对位置。对于冒泡排序而言，则就是单纯的两两进行比较，知道不能再继续冒泡为止。
我们通过【45,34,78,12,34’,32,29,64】数组为例，进行讲解。

i值	过程
i=0	j=7 A【7】和A【6】;64>29,不逆置；j=6 A【6】和A【5】29<32,逆置；j=5 A【5】和A【4】29<34’,逆置；…12最后和45进行交换，交换完之后的排序：12,45,34,78,29,34’,32,64
i=1	32左移冒到34’左侧，29左移冒到45左侧，交换完之后的排序：12,29,45,34,78,32,34’,64
i=2	32左移冒到45左侧，交换完之后的排序：12,29,32,45,34,78,34’,64
i=3	34’左移冒到78左侧，34左移冒到45左侧，交换完之后的排序：12,29,32,34,45,34’,78,64
i=4	64左移冒到78左侧，34’左移冒到45左侧，交换完之后的排序：12,29,32,34,34’,45,64,78
i=5	无可冒泡的数，冒泡过程结束

遇到碰见比我大的我就插队，往前走，就好似上学时候我们排队似的，一层一层的两两比较，长得矮的一点一点的往前挪。
冒泡排序代码如下：

public static void main(String[] args) {
        int[] array = {49,38,65,97,76,13,27,49};
        bubleSort(array,array.length);
        System.out.println(Arrays.toString(array));
    }

    static void bubleSort(int[] arr,int n){
        boolean NoSwap;
        int i,j;
        int temp;
        for (i=0;i<n-1;i++){
            //标识初始为真
            NoSwap=true;
            for (j=n-1;j>i;j--){
                //判定arr[j]<arr[j-1]是否逆置
                if (arr[j]<arr[j-1]){
                    temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                    //发生了交换，标志变为假
                    NoSwap=false;
                }
            }
            //如果没发生过交换，则表示已经排好序，结束算法
            if (NoSwap){
                return;
            }
        }
    }

而对于冒泡排序的时间复杂度，最佳情况则是一个正序数组，只需要比较i=0一次即可，所以最大时间复杂度为O(n);
而最坏的情况则是，最外层循环n-1次，内层for循环需比较n-i次，最多交换n-i次。所以最坏的情况的时间复杂度为n(n-1)/2求和，为O(n^2)。

2021年10月12日21:14:39更新：
不需要多余参数，直接双层循环实现,通过j,j+1对比

public static void main(String[] args) {
		int[] arr = {45,34,78,12,34',32,29,64};
		//外层循环控制排序趟数
		for (int i = 0; i < arr.length - 1; i++) {
			//内层循环控制每一趟排序多少次
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		for (int num : arr) {
			System.out.print(num + " ");
		}
	}

（只展示了i=0和i=1，剩余的都是如此流程。i控制循环趟数，j控制每次循环多少次）