java实现冒泡排序

基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止（大话数据结构）

白话翻译：从位置0开始，比较前i个数中，相邻两个数的大小。大的换到后面。小的换到前面。这就像轻的水泡向上冒。所以叫冒泡排序

冒泡排序中，一趟排序，就会把前length-1-i个数中最大数沉底。比如下图：

冒泡排序总是从0个位置开始，到上次排好序的位置为止。两两交换逆序元素

代码：

public class MaoPao {
    public static void main(String[] args){
        int[] arrays = {4,2,3,1,5,8,9,6};
        msort(arrays);
        for(int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }

    }
    public static  int[] msort(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            for(int j=0;j<arrays.length-1-i;j++){
                if(arrays[j]>arrays[j+1]){
                    int temp = arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=temp;
                }
            }
        }
        return arrays;
    }
}

优化：上面的代码要排序n-1趟，并且每趟都要比较相邻两个数的大小。如果数组在中间任何一趟就排好序的话，后面的比较都是在浪费资源

使用一个boolean类型来记录是否进行了交换。如果没有交换，意味着数组已经正序，直接退出比较

public class MaoPao {
    public static void main(String[] args){
        int[] arrays = {4,2,3,1,5,8,9,6};
        msort(arrays);
        for(int i=0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }

    }
    public static  int[] msort(int[] arrays){
        
        for(int i=0;i<arrays.length;i++){
        	boolean flag = false;
            for(int j=0;j<arrays.length-1-i;j++){
                if(arrays[j]>arrays[j+1]){
                    int temp = arrays[j];
                    arrays[j]=arrays[j+1];
                    arrays[j+1]=temp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return arrays;
    }
}

时间复杂度分析：

如果数组正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，

即：Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。

如果数组是逆序的的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

即最坏情况下时间复杂度为O(n^2)

所以，冒泡排序总的平均时间复杂度为：O(n^2) 。