冒泡排序

• 冒泡排序最为出名的排序算法之一，共八大排序

• 代码相当简单：两层循环，外层冒泡层数，里层对数组依次比较和交换

• 时间复杂度O（n2）

• 常考算法：重点 冒泡法：两层循环：外层冒泡轮数，里层依次比较

1. 如果数组中第一个数比第二个数大，我们就交换他们的位置
2. 每次比较都有一个最大，或者最小的数字
3. 下一轮则可以少一次排序
4. 依次循环直到结束

1，定义数组

int[] a = {1,3,5,4,2,8,7,6,9,10};

2.冒泡代码外循环

• 外循环：判断循环次数 注意：只有比较到a.length-1

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

3.冒泡代码内循环

• 内循环：比价判断两个数

for(int j = 0;j < a.length-1-i;j++){
    //比较完之后交换两者
    if(a[j+1]<a[j]){
        //a[i] = a[j];错误方式：直接赋值的方式导致a数组里的值因为赋值变化了
        temp = a[j];
        a[j] = a[j+1];
        a[j+1] = temp;
     }
 }

4.冒泡代码

public static int[] sort(int[] a){
        boolean flag = false;//如果数组本身排好序，通过flag标志位减少没有意义的比较
        int temp = 0;//临时变量

        //外循环：判断循环次数   注意：只有比较到a.length-1
        for(int i = 0;i < a.length-1;i++){
            //内循环：比价判断两个数
            for(int j = 0;j < a.length-1-i;j++){
                //比较完之后交换两者
                if(a[j+1]<a[j]){
                    //a[i] = a[j];错误方式：直接赋值的方式导致a数组里的值因为赋值变化了
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        return a;
    }
}

6.减少一次比较

 public static int[] sort(int[] a){
        boolean flag = false;//如果数组本身排好序，通过flag标志位减少没有意义的比较
        int temp = 0;//临时变量

        //外循环：判断循环次数   注意：只有比较到a.length-1
        for(int i = 0;i < a.length-1;i++){
            //内循环：比价判断两个数
            for(int j = 0;j < a.length-1-i;j++){
                //比较完之后交换两者
                if(a[j+1]<a[j]){
                    //a[i] = a[j];错误方式：直接赋值的方式导致a数组里的值因为赋值变化了
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                    flag = true;//当到a.length-1个的时候，不用比较了直接终止
                }
            }
            if(flag==false){
                break;
            }
        }
        return a;
    }
}