十大经典算法冒泡排序及优化方法（java实现）

1.算法逻辑

• 比较两个数的大小，如果第一个大于第二个，那么就交换位置；
• 第一轮：从第一个开始和第二个比，大的那个成为第二个 ，接着第二个和第三个比，大的成为第三个，第三个和第四个比，大的成为第四个，直到产生第N个，那么第N个是最大的；
• 第二轮：从第一个开始和第二个比，大的那个成为第二个 ，接着第二个和第三个比，大的成为第三个，直到产生第N-1个（不要到N个，因为第N个最大）；
• 重复比较

2.代码实现

public class Boolesort {
    public static void main(String[] args) {
        //调用方法
        int  i[] = {6,2,3,4};
        int b[] = boolesortIpm(i);
        for (int k=0;k<b.length;k++){
            System.out.println(b[k]);
        }
    }
    //普通的冒泡排序算法
    public static int[] boolesort(int a[]){
        //获取数据长度
        int len = a.length;
        for(int i=0;i<len-1;i++){
            for(int j=0;j<len - i -1;j++){
                    if(a[j]<a[j+1]){
                        int temp = a[j];
                        a[j] = a[j+1];
                        a[j+1] = temp;
                    }
            }
        }

        return a;
    }

    //改进后的冒泡排序算法 第一版 增加标志为 避免有序后再次排序
    public static int[] boolesortIpm(int a[]){
        //设置标志位
        boolean flag=true;

        for(int j=0;j<a.length-1;j++){

            for (int k=0;k<a.length-1-j;k++){
                if(a[k]<a[k+1]){
                    int temp = a[k];
                    a[k] = a[k+1];
                    a[k+1] = temp;
                    flag =false;
                }
            }
        }
        if (flag){
            return a;
        }
        return a;
    }

    //再次改进代买
    public static int[] boolesortIpmn(int a[]){
        boolean flag = true;
        //最后的的交换位置
        int lastexchange = 0;
        //比较的边界
        int sortedborder = a.length -1;
        for (int i =0;i<a.length-1;i++){
            for(int j=0;j<sortedborder;j++){
                if(a[j] < a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = a[j];

                    flag = false;
                    lastexchange = j;
                }

            }
            sortedborder = lastexchange;
            if(flag){
                return a;
            }
        }
        return a;
    }

}

3.复杂度分析

• 最优的时间复杂度为：O( n^2 ) ；
• 最差的时间复杂度为：O( n^2 )；
• 平均的时间复杂度为：O( n^2 )；

参考链接：

冒泡算法改进：https://www.cnblogs.com/mistermoney/p/9550590.html

java数组操作：https://blog.csdn.net/mrbacker/article/details/81638331