【数据结构19】冒泡排序

文章目录

• 1. 冒泡排序介绍
• 2. 冒泡排序规则
• 3. 基本冒泡排序实例
• 4. 冒泡排序优化

1. 冒泡排序介绍

2. 冒泡排序规则

3. 基本冒泡排序实例

冒泡排序原理：

ublic class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,9,-1,10,-2};

        //第一趟排序就是把最大的数排在后面
        int temp = 0;
        for(int i=0;i<arr.length-1;i++){
            //如果前面的数比后面的数大就交换
            if(arr[i]>arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第一趟排序后的数组："+ Arrays.toString(arr));

        //第二趟排序就是把第二大的数据排在倒数第二位
        for(int i=0;i<arr.length-1-1;i++){
            //如果前面的数比后面的数大就交换
            if(arr[i]>arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第二趟排序后的数组："+ Arrays.toString(arr));


        //第三趟排序就是把第三大的数据排在倒数第三位
        for(int i=0;i<arr.length-1-1-1;i++){
            //如果前面的数比后面的数大就交换
            if(arr[i]>arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第三趟排序后的数组："+ Arrays.toString(arr));


        //第四趟排序就是把第四大的数据排在倒数第四位
        for(int i=0;i<arr.length-1-1-1-1;i++){
            //如果前面的数比后面的数大就交换
            if(arr[i]>arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第四趟排序后的数组："+ Arrays.toString(arr));
    }
}

最终冒泡排序算法：

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,9,-1,10,-2};

        //第一趟排序就是把最大的数排在后面
        int temp = 0;
        //冒泡排序的时间复杂度为o(n^2)
        for(int j=0;j<arr.length-1;j++){
            for(int i=0;i<arr.length-1-j;i++){
                //如果前面的数比后面的数大就交换
                if(arr[i]>arr[i+1]){
                    temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
            System.out.println("第"+(j+1)+"趟排序后的数组：");
            System.out.println(Arrays.toString(arr));
        }
    }
}

4. 冒泡排序优化

我们发现分析的排序有可能排两趟就结束了，那么这时就不需要再进行排序了，可以进行优化：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3,9,-1,10,20};
       bubbleSort(arr);
    }

    public static void bubbleSort(int[] arr){
        //第一趟排序就是把最大的数排在后面
        int temp = 0;
        //标识变量，标识是否进行过交换
        boolean flag = false;
        for(int j=0;j<arr.length-1;j++){
            for(int i=0;i<arr.length-1-j;i++){
                //如果前面的数比后面的数大就交换
                if(arr[i]>arr[i+1]){
                    flag = true;
                    temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
            System.out.println("第"+(j+1)+"趟排序后的数组：");
            System.out.println(Arrays.toString(arr));

            if(!flag){//如果一次都没有交换过，直接结束for循环
                break;
            }else{//如果交换过，将falg设置为false
                flag = false;
            }
        }
    }
}

来源：CSDN

作者：茶花女-

链接：https://blog.csdn.net/qq_42764468/article/details/103746576