八大排序之冒泡排序（java实现）

最新推荐文章于 2023-03-21 14:42:47 发布
最新推荐文章于 2023-03-21 14:42:47 发布
阅读量156 收藏 1
点赞数 1
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37215985/article/details/120611174
版权

java 算法 数据结构

冒泡排序：

基本介绍：

冒泡排序的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），一次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后面，就像水里的气泡一样逐渐向上冒。
blue~
bule~ blue~
blue~
鱼吐泡泡

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行多交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。

冒泡分析：

定义一个原始数组：2,8，-1,10,21
第一趟排序：

（1）2,8,-1,10,21
（2）2,-1,8,10,21
（3）2,-1,8,10,21
（4）2,-1,8,10,21
第二趟排序：
（1）-1,2,8,10,21
（2）-1,2,8,10,21
（3）-1,2,8,10,21
第三趟排序：
（1）-1,2,8,10,21
（2）-1,2,8,10,21
第四趟排序：
（1）-1,2,8,10,21

冒泡排序总结：

（1）一共进行数组的大小-1次的循环
（2）每一趟排序的次数在逐渐的减少，如果没有进行变化，就提前结束。

package DataStructures.sort;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        //给出一个数组{3,8,-2,9,-3}
        int arr[] = {3, 8, -2, 9, -3};
        //把冒泡排序的演变过程展示一下
        /*
         * 第一趟，将最大的数排在最后
         * */

       /* //冒泡排序的时间复杂度O(n^2)
        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.printf("第%d趟排序后的数组:\n", i + 1);
            System.out.println(Arrays.toString(arr));
        

      
         * 第二趟，将arr.length-2大的数排在最后
         *//*
        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));

        *//*
         * 第三趟，将arr.length-3大的数排在最后
         * *//*
        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));

        *//*
         * 第四趟，将arr.length-4大的数排在最后
         * *//*
        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));
    }
}

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.printf("第%d趟排序后的数组:\n", i + 1);
    System.out.println(Arrays.toString(arr));
    if (!flag) {
        //在一趟排序中，一次交换都没有发生过
        break;
    } else {
        flag = false;//重置flag，进行下次判断
    }
}

优化后的代码：

package DataStructures.sort;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        //给出一个数组{3,8,-2,9,-3}
        int arr[] = {3, 8, -2, 9, -3};
        //把冒泡排序的演变过程展示一下
        /*
         * 第一趟，将最大的数排在最后
         * */
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
//测试冒泡排序
        bubbleSort(arr);
        System.out.println("排序后");
        System.out.println(Arrays.toString(arr));

       /* //冒泡排序的时间复杂度O(n^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.printf("第%d趟排序后的数组:\n", i + 1);
            System.out.println(Arrays.toString(arr));
            if (!flag) {
                //在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false;//重置flag，进行下次判断
            }
        }*/

        /*
         * 第二趟，将arr.length-2大的数排在最后
         *//*
        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));

        *//*
         * 第三趟，将arr.length-3大的数排在最后
         * *//*
        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));

        *//*
         * 第四趟，将arr.length-4大的数排在最后
         * *//*
        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));*/

    }

    //将前面的冒泡排序算法，封装成 一个方法
    public static void bubbleSort(int arr[]) {
        //冒泡排序的时间复杂度O(n^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.printf("第%d趟排序后的数组:\n", i + 1);
//            System.out.println(Arrays.toString(arr));
            if (!flag) {
                //在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false;//重置flag，进行下次判断
            }
        }

    }
}

测试八万数据的时间消耗：

package DataStructures.sort;

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

public class BubbleSort {
    public static void main(String[] args) {
        //给出一个数组{3,8,-2,9,-3}
        //int arr[] = {3, 8, -2, 9, -3};
        //把冒泡排序的演变过程展示一下
        /*
         * 第一趟，将最大的数排在最后
         * */
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000);//生成80000个随机数【0,80000000】
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间：" + data1Str);
        bubbleSort(arr);
        Date data2 = new Date();
        //new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间：" + data2Str);
//        System.out.println("排序前");
//        System.out.println(Arrays.toString(arr));
//测试冒泡排序
//        bubbleSort(arr);
//        System.out.println("排序后");
//        System.out.println(Arrays.toString(arr));

       /* //冒泡排序的时间复杂度O(n^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.printf("第%d趟排序后的数组:\n", i + 1);
            System.out.println(Arrays.toString(arr));
            if (!flag) {
                //在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false;//重置flag，进行下次判断
            }
        }*/

        /*
         * 第二趟，将arr.length-2大的数排在最后
         *//*
        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));

        *//*
         * 第三趟，将arr.length-3大的数排在最后
         * *//*
        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));

        *//*
         * 第四趟，将arr.length-4大的数排在最后
         * *//*
        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));*/

    }

    //将前面的冒泡排序算法，封装成 一个方法
    public static void bubbleSort(int arr[]) {
        //冒泡排序的时间复杂度O(n^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.printf("第%d趟排序后的数组:\n", i + 1);
//            System.out.println(Arrays.toString(arr));
            if (!flag) {
                //在一趟排序中，一次交换都没有发生过
                break;
            } else {
                flag = false;//重置flag，进行下次判断
            }
        }

    }
}
“HelloWorld”
关注
专栏目录
八大排序算法之冒泡排序（Java实现）
qq_40396568的博客
06-07 163
第一轮，4和5比较，5和6比较.....2和1比较 总共比较5次（length-1） 第二轮 6固定（冒在最上方），无需再比较 4和5比较.....2和1比较 总共比较4次（length-2） 第三轮 6 5固定 4和3比较.....2和1比较 总共比较3次（length-3） 第四轮 总共比较2次（length-4） 第五轮 总共比较1次（length-5） 第六轮 总共比较0次（length-5） 代码实现 package Sort; pub...
Java 八大排序之冒泡排序详解
m0_64334884的博客
06-07 302
数组[24,69,80,57,13]第1轮排序:目标把最大数放在最后 第1 次比较:[24,69,80,57,13] 第2 次比较:[24,69,80,57,13] 第3 次比较:[24,69,57,80,13] 第4 次比较:[24,69,57,13,80]第2轮排序:目标把第二大数放在倒数第二位置 第1次比较:[24,69,57,13,80] 第2次比较:[24,57,69,13,80] 第3次比较:[24,57,13,69,80]第3轮排序:目标把第三大数放在倒数第三位置 第1次比较:[24,57,1
Java中常见的排序算法
学英语的程序员
10-23 268
排序相关的的基本概念 排序：将一组杂乱无章的数据按一定的规律顺次排列起来。数据表( data list): 它是待排序数据对象的有限集合。排序码(key):通常数据对象有多个属性域，即多个数据成员组成,其中有一个属性域可用来区分对象,作为排序依据。该域即为排序码。每个数据表用哪个属性域作为排序码，要视具体的应用需要而定。 我们常见的一些排序算法，如图所示： 交换排序 交换排序的...
冒泡排序-java语言版
Jantoor的博客
10-19 92
冒泡排序 排序原理 1、比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。 2、对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大 ...
冒泡排序 java
追求卓越-朝着架构师的方向努力
04-25 747
package com.alexander.sort.implementation; public class BubbleSort { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int[] arr = { 90, 20,
Java经典排序—冒泡排序
Kevin_Gu6的博客
03-11 380
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 冒泡排序算法的运作如下： 一、比较相邻的元素，如果第一个比第二个大，就交换他们两个； 二、对每一对相邻元素作同样...
经典排序之冒泡排序(Java)
qq_43404873的博客
11-10 265
排序算法的介绍 排序也称排序算法(Sort Algorithm),排序是将一组数据，依指定的顺序进行排列的过程。 排序的分类: 内部排序: 指将需要处理的所有数据都加载到内部存储器(内存)中进行排序。 外部排序: 数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序 常见的排序算法分类: 算法的时间复杂度 度量一个程序(算法)执行时间的两种方法 1.事后统计的方法: 这种方法可行，但是有两个问题，一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计
八大排序-java实现版
03-01
八大排序java实现版本，直接插入排序、折半插入排序、冒泡排序、简单选择排序、希尔插入排序、快速排序 、堆排序、2-路归并排序 、基数排序，并有时间比较，博文...
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨Java实现的八个经典排序算法，包括它们的工作原理、时间复杂度以及如何用Java代码实现。 1. **插入排序(Insertion Sort)** 插入排序是一种简单直观的排序算法，它的工作原理是通过构建...
冒泡排序java实现
04-12
标签中的“八大排序”指的是计算机科学中常见的八种排序算法：冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序、希尔排序和计数排序。这些排序算法各有特点，适用场景也不同，理解它们可以帮助我们更好地...
Java实现八大排序中的冒泡排序（牢记）
最新发布
qq_46601365的博客
03-21 78
【代码】Java实现八大排序中的冒泡排序（牢记）
Java常见排序算法之冒泡排序、选择排序、插入排序、快速排序
c1441173216的博客
11-08 1072
Java实现常见的排序算法 冒泡 选择 插入 快速排序。代码清晰易懂
冒泡排序(java)——3种方法
Shliry的博客
10-02 3622
这里的冒泡是按照从小到大的顺序来的 思想：将相邻的元素两两比较， 当一个元素大于右侧相邻的元素时，交换他们的位置；当一个元素小于右侧相邻的元素时，不做任何改变。 一、第一种方法 public static void main(String[] args) { int[] array = new int[]{5, 8, 6, 3, 9, 2, 1, 7}; sort(array); System.out.println(Arrays.toString(array)); }
排序算法：冒泡排序
HelloWorld搬运工
08-27 5142
冒泡排序是一种交换排序。 什么是交换排序呢？ 交换排序：两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。 算法思想 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端，故名。 假...
冒泡排序4种写法-java
只此浮生是梦中
03-23 1万+
写一点自己对冒牌排序的理解： int[] arr = new int[length]; 1，通过对比相邻2个数，得到最大/最小数； 1&gt;从前往后比，每次筛选出最后一位 for(int i=0;i&lt;arr.length;i++){ //需要对比几轮 for(int j=0;j&lt;arr.length-i-1;j++){ //每轮需对比几次 //从0依次...
Java冒泡排序的6种写法（1）
热门推荐
自天祐之，吉，无不利。
07-28 1万+
/** * */ package ch02;/** * @author Administrator *sorting algorithm */ public class javaData1 {// public static void swap(Long a,Long b){ // long tmp; // tmp=a; // a=b; // b
java实现冒泡排序的三种方式
无名丶任性
08-12 5077
冒泡排序主要思想是比较前后两个元素的大小如果a[i]>a[i+1]则交换两个元素的值 import java.util.Random; public class SortTest { static int a[] = new int[100000]; static{ for (int i = 0; i < 100000; i++) { Random random = new Random(100000); a[
java 冒泡排序的三种写法_冒泡排序的三种实现(Java)
weixin_35999669的博客
02-13 1084
冒泡排序是非常好理解的，以从小到大排序为例，每一轮排序就找出未排序序列中最大值放在最后。设数组的长度为N：(1)比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。(2)这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。(3)N=N-1，如果N不为0就重复前面二步，否则排序完成。以上就是冒泡排序的基本思想，按照这个定义很快就能写出代...
java之冒泡排序8个数
令狐_JackieHao的博客
09-24 3231
文章目录一.实现思路二.冒泡排序三.代码实现 一.实现思路       我们在实现这8个数排序主要思路是：先用一个数组存取8个数字，然后使用冒泡排序从小到大进行排序。 二.冒泡排序 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针...
Java实现八大排序算法演示
2. **八大排序算法**： - **快速排序**：由C.A.R. Hoare提出的分治策略，通过选取一个基准值，将数组分为小于和大于基准的两部分，然后递归地对这两部分进行排序。 - **冒泡排序**：通过不断地交换相邻的逆序元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

“HelloWorld”

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值