002排序算法之冒泡排序

最新推荐文章于 2024-05-31 09:25:19 发布
最新推荐文章于 2024-05-31 09:25:19 发布
阅读量103 收藏 1
点赞数
分类专栏： # 算法笔记 文章标签： 排序算法 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46635575/article/details/120912718
版权

下面你可以获得以下知识

  • 了解冒泡排序是什么！
  • 知道冒泡排序的思路
  • 知道实例代码并且练习
  • 有收获记得帮忙点个赞，有问题请指出。

系列文章

一、冒泡排序基本介绍

1、冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前往后（从下标较小的元素开始）依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前往后移动，就像水底的气泡一样向上冒出。

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

3、冒泡排序的图解思路

其实就是两个指针，移动来进行判断，然后如此循环进行比较 ，具体思路大致如下：

  • 第一轮循环得到最大值
  • 第二轮循环得到第二大值
  • 第三轮循环得到第三大值
  • 第四轮循环得到第四大值
  • 总的要进行数组大小减1的词循环
    在这里插入图片描述

二、冒泡排序代码实现

package cn.mldn;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3,9,-1,10,-2};
        //大致过程
        //1、第一步就是第一轮排序得到最大值于最后
        //  for (int i = 0; i < arr.length - ; i++) {
        //            //如果前面的数比后面的数大，则交换
        //            if (arr[i] > arr[i+1]) {
        //                temp = arr[i];
        //                arr[i] = arr[i + 1];
        //                arr[i + 1] = temp;
        //            }
        //        }
        //2、第二糖就是把倒数第二大的排到倒数第二位
        //  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;
        //            }
        //        }
        //3、第三糖排序，以此内推
        //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;
        //            }
        //        }
        //4、第四次排序，以此内推
        //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;
        //            }
        //        }
        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;
            }
        }

        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;
            }
        }

        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;
            }
        }

        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("hello " + Arrays.toString(arr));
        //------------------------------------------------------------------------------------
        //根据上面的观察可以知道了撒，可以再用一套循环解决


        //好好理解一下、由此可知，他的时间复杂度为O(n*n)
        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;
                }
            }
        }
    }
}

三、冒泡排序的优化

1、思路
如果我们发现在某一糖过程中，没有进行一次交换，提前终止
2、代码实现

package cn.mldn;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3,9,-1,10,-2};
        //大致过程
        //1、第一步就是第一轮排序得到最大值于最后
        //  for (int i = 0; i < arr.length - ; i++) {
        //            //如果前面的数比后面的数大，则交换
        //            if (arr[i] > arr[i+1]) {
        //                temp = arr[i];
        //                arr[i] = arr[i + 1];
        //                arr[i + 1] = temp;
        //            }
        //        }
        //2、第二糖就是把倒数第二大的排到倒数第二位
        //  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;
        //            }
        //        }
        //3、第三糖排序，以此内推
        //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;
        //            }
        //        }
        //4、第四次排序，以此内推
        //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;
        //            }
        //        }
        /*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;
            }
        }

        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;
            }
        }

        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;
            }
        }

        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("hello " + Arrays.toString(arr));
        //------------------------------------------------------------------------------------
        //根据上面的观察可以知道了撒，可以再用一套循环解决



        //好好理解一下、由此可知，他的时间复杂度为O(n*n)
        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;//在这里把flag值为true
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            //在内部循环的时候进行查询
            if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
                break;
            } else {
                flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
            }
        }

        System.out.println("world " + Arrays.toString(arr));
    }
}

四、将上面的代码封装为一个方法

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

        bubbleSort(arr);
        System.out.println("world " + Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        //好好理解一下、由此可知，他的时间复杂度为O(n*n)
        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;//在这里把flag值为true
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            //在内部循环的时候进行查询
            if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
                break;
            } else {
                flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
            }
        }
    }
}

五、测试一下冒泡排序的时间复杂度

1、代码是实现

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

public class BubbleSort {
    public static void main(String[] args) {
        //1、创建80000个数据来测试一下我们的性能
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int)(Math.random()*80000);//生成0到80000的数
        }
        //2、输出时间
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");//格式化
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间" + date1Str);
        bubbleSort(arr);
        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间" + date2Str);


    }

    public static void bubbleSort(int[] arr) {
        //好好理解一下、由此可知，他的时间复杂度为O(n*n)
        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;//在这里把flag值为true
                    temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
            //在内部循环的时候进行查询
            if (!flag) {//说明在第一趟排序过程中一次交换都没有发生。
                break;
            } else {
                flag = false;//没有这个就是执行一遍就没了，要让他进行下次继续
            }
        }
    }
}

2、效果
在这里插入图片描述

同学郑学习
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言排序算法之冒泡排序
12-25
C语言排序算法之冒泡排序
[交换排序] 冒泡排序（两种优化）、快速排序（3种方法+两种优化）
Darling_sheeps的博客
10-20 1215
文章目录一、冒泡排序1.1 基础的冒泡排序1.2 冒泡排序的优化二、快速排序2.1 基础的快速排序2.1.1 双指针法2.1.2 挖坑法2.1.3 前后指针法2.2 快排的优化（在一定范围内使用直接插入排序）2.3 快排的优化（使用三数取中法确定基准值） 一、冒泡排序 1.1 基础的冒泡排序   算法思想：从后向前，相邻两个元素进行两两比较，如果后面的元素的值小于前面元素的值，就交换两个元素。一趟冒泡下来，最小的元素就会被放到最前面的位置。这样最多进行n-1趟冒泡，就会把所有的元素全部排好。   相关代码如
LeetCode-数组-双指针-中等难度
自律使我自由
01-04 978
双指针一般是指利用两个变量，通过在线性的结构上进行遍历来解决某些特定的问题，按照遍历的方式一般多采用：同向遍历，相向遍历两种方式，例如冒泡排序、选择排序、插入排序都是用了两个变量同向遍历来实现，快排则是通过相向遍历来实现。要求可接的雨水处的水量，可以先分别求出位于此处两侧最长柱子的高度，然后取其较短的一根即表示其可接水量的上限，因此完全可以通过不断的左右遍历（收缩较短的柱子）的方式计算出每个位置可接的水量。个后，再进行比较，所以快指针逻辑不变，只需要让慢指针在比较时每次往前取两位即可。左右指针，相向遍历。
冒泡排序，快速排序，堆排序，滑动窗口，双指针
weixin_42819084的博客
08-01 351
冒泡排序 这个算法的核心之处就是在每个相邻的元素都进行比较，如果不是按顺序的形式，就彼此交换。这个算法不适合用于大数据量的排序，因为它的平均时间复杂度和最差时间复杂度都是o（n^2）。 写代码时，N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。 n=len(arrList) for i in range(n-1): for j in range(n-1-i)： if arrList[i+1] < ar
c语言指针实现冒泡排序及其优化
热门推荐
mxrrr_sunshine的博客
11-19 1万+
冒泡排序是一个十分容易实现的算法，简单说明一下： 假设数组长度为 N，要求从小到大排序： 1从第一个数开始比较相邻两个元素，如果前面的数据大于后面的数据，就将二个数据交换。 2对数组元素进行一次第一次遍历后，最大的数据就’沉’到了数组最后一个位置。 3重复遍历过程，直到N-1次，此时排序完成。 用一张网上的图来大致说明一下： 给出实现的代码：void Bubble_Sort(int
冒泡排序（笔记）
m0_52403880的博客
03-06 187
冒泡排序 原理是：内循环： 使用相邻双指针 j , j + 1 从左至右遍历，依次比较相邻元素大小，若左元素大于右元素则将它们交换；遍历完成时，最大元素会被交换至数组最右边 。外循环： 不断重复「内循环」，每轮将当前最大元素交换至剩余未排序数组最右边 ，直至所有元素都被交换至正确位置时结束。 冒泡排序是稳定的排序方法。 时间复杂度为 ：O(n^2) 空间复杂度为 ：O(1) public static void bubbleSort(int[] arr){ for (int i = 0; i
C语言冒泡排序：指针和数组两种方法
qq_44631587的博客
08-04 590
冒泡排序 #define _CRT_SECURE_NO WARINGS 1 #include<stdio.h> #include<windows.h> //打印输出函数 void Print(int ar[], int size) { for (int i = 0; i <size; i++){ printf("%d ",ar[i]); } printf("\n"); } //用Swap函数来交换两个变量的值 void Swap(int* a, int* b) {
Go 指针和非指针方式实现冒泡排序算法
Mike铭
03-23 270
Go 指针和非指针方式实现冒泡排序算法 本文将用指针和非指针方式实现go的冒泡排序算法 指针实现 package main import ( "fmt" ) func bubbleSort(arr *[]int){ length := len(*arr) for i :=0 ; i < length;i++{ for j := i+1 ; j< length; j++{ ...
C++ 排序算法之冒泡排序
07-25
C++ 排序算法之冒泡排序
C++排序算法之冒泡排序源码
06-29
C++排序算法之冒泡排序源码
排序算法之冒泡排序（图解）
11-21
排序算法之冒泡排序（图解）
C语言练习之排序算法：冒泡排序
01-16
在初学C语言时，比较重要的知识点就是排序算法，这里提供了一种冒泡排序算法的实现路径，供广大学习者参考。
Java排序算法(六)：希尔排序
最新发布
十三月的博客
05-31 172
它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，再经过一次插入排序，算法便终止。
排序进阶----插入排序，希尔排序
2302_80318761的博客
05-29 993
大家可以想一下，我们如果以扑克牌为例，我们利用冒泡排序的话，每一个位置就要对比一下，这很麻烦，很耗时间的。但是如果我用插入排序的话，我们以第一个数为例，一次向后对比，如果他比接下来对比的数都大的话，那么我就先把战船一直比较比他更大的数，那么我就把它插入在前面。我们先从第一趟开始，比如说我们就先走第一趟，以下标为零开始的与下标为一对比，如果他比第一个大的话，那么这一趟就结束，我们就只循环一次。当然希尔排序其实是有一点困难的，大家需要多理解一点多看一下，其实相对还是比较简单的，只需要理解之后大家都能写出来的。
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 249
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 330
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 462
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 592
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 915
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
双向冒泡排序算法实现冒泡排序python
05-17
冒泡排序是一种简单的排序算法，也是常见的排序方式之一。在 Python 中，可以使用双向冒泡排序算法来实现冒泡排序。该算法是在传统的冒泡排序基础上进行了优化，可以减少排序过程中的比较次数和交换次数。 下面是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值