冒泡排序详解

最新推荐文章于 2024-05-17 00:28:43 发布

度心℃

最新推荐文章于 2024-05-17 00:28:43 发布

阅读量184

点赞数

分类专栏：算法

本文链接：https://blog.youkuaiyun.com/James____Gosling/article/details/117669023

版权

算法专栏收录该内容

20 篇文章

订阅专栏

这篇博客详细介绍了冒泡排序的原理和实现过程，包括基本版、精简版和升级版的代码实现。升级版中加入了性能测试，通过生成随机数组并进行排序，对比排序前后的系统时间，展示了冒泡排序的效率。同时，博客还利用布尔标志来优化冒泡排序，当某趟排序未发生交换时提前结束，提高了排序效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序思想：通过下标从小到大开始，依次比较相邻元素，若发现逆序则交换，使较大的元素注解从前往后移。
在这里插入图片描述

冒泡排序规则：
1、一共进行数组的大小-1次大的循环
2、每一趟排序的次数在逐渐的减少
3、如果我们发现在某趟排序时，没有发生一次交换，可以几天结束循环；

冒泡排序代码演示：

package com.sort;

import java.util.Arrays;

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

        //冒泡排序演变过程：
        //第一趟排序，就是将最大那个数，排在最后
        for (int i =0;i< arr.length-1;i++){
            int temp=0;//临时变量，
            for (int j = 0; j < arr.length-1-i; j++) {
                //如果前面的数比后面的数大，则交换
                if (arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.println("第"+(i+1)+"趟冒泡排序");
            System.out.println(Arrays.toString(arr));
        }

          /*int temp=0;//临时变量，
        for (int j = 0; j < arr.length-1; j++) {
            //如果前面的数比后面的数大，则交换
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
        System.out.println("第一趟排序");
        System.out.println(Arrays.toString(arr));


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

        // 第三趟排序，将第二大的数据排在倒数第二位
        for (int j = 0; j < arr.length-3; j++) {
            //如果前面的数比后面的数大，则交换
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
        System.out.println("第四趟排序");
        System.out.println(Arrays.toString(arr));

        // 第三趟排序，将第二大的数据排在倒数第二位
        for (int j = 0; j < arr.length-4; j++) {
            //如果前面的数比后面的数大，则交换
            if (arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
        System.out.println("第四趟排序");
        System.out.println(Arrays.toString(arr));*/
    }
}

精简版：

package com.sort;

import java.util.Arrays;

//冒泡排序优化，结束没有必要的循环
public class BubbleSort1 {
    public static void main(String[] args) {
        int arr[] = {3,9,-1,10,-2};
        int temp=0;
        boolean flag= false;//标识变量，表示是否进行过交换
        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]){
                    flag = true;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println(Arrays.toString(arr));

            if (flag == false){//在一趟排序中，一次交换都没有发生
                break;
            }else {
                flag = false;//重置flag，进行下一次判断
            }
        }

    }
}

升级版：

package com.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.logging.SimpleFormatter;

public class BubbleSort {
    public static void main(String[] args) {
        //int  arr[] = {3,9,-1,10,-2};
        int[] arr=new int[800000];
        for (int i =0;i<800000;i++){
            arr[i]=(int)Math.random() * 8000000;
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间"+ data1Str);
        bubbleSort(arr);
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间"+ data2Str);
    }

    //将前面的冒泡排序封装成一个方法
    public static void bubbleSort(int[] arr){
        int temp=0;//临时变量，
        boolean flag = false;
        //冒泡排序演变过程：
        //第一趟排序，就是将最大那个数，排在最后
        for (int i =0;i< arr.length-1;i++){
            for (int j = 0; j < arr.length-1-i; j++) {
                flag=true;
                //如果前面的数比后面的数大，则交换
                if (arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
//            System.out.println("第"+(i+1)+"趟冒泡排序");
//            System.out.println(Arrays.toString(arr));
            if (flag == false){//在一趟排序中，一次交换都没有发生
                break;
            }else {
                flag = false;//重置flag，进行下一次判断
            }
        }
    }
}