排序方式（8种）详解1—冒泡排序

最新推荐文章于 2024-08-26 09:09:41 发布
最新推荐文章于 2024-08-26 09:09:41 发布
阅读量1.8k 收藏 7
点赞数 2
分类专栏： 排序算法 算法数据结构 文章标签： java 数据结构 算法 ide
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54353206/article/details/124061958
版权

目录

  1、冒泡排序概述

2、冒泡排序分类：

3、代码展示和调试

冒泡排序1(原始版)

冒泡排序2(递归版1)

冒泡排序3(递归版2)

冒泡排序4(优化版)

冒泡排序5(升级版)

留言：为作者一人拙见，仅参看使用，如有帮助，不甚荣幸。

  1、冒泡排序概述

      冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。原理：每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面两个相邻的两个数大小关系，重复此步骤，直到最后一个还没归位的数。

2、冒泡排序分类：

      冒泡排序1(原始版)、冒泡排序2(递归版1) 、冒泡排序3(递归版2) 、冒泡排序4(优化版)、冒泡排序5(升级版)

3、代码展示和调试

public static void main(String[] args) {
        int[] num=new int[]{3,45,89,53,12,19,6,20,75,66,90,30,67,3,1,2,3,4,5,6,68,98,99,76,65,66,33,43,32,43};
        int[] num1=new int[]{3,45,89,53,12,19,6,20,75,66,90,30,67,3,1,2,3,4,5,6,68,98,99,76,65,66,33,43,32,43};
        int[] num2=new int[]{3,45,89,53,12,19,6,20,75,66,90,30,67,3,1,2,3,4,5,6,68,98,99,76,65,66,33,43,32,43};
        int[] num3=new int[]{3,45,89,53,12,19,6,20,75,66,90,30,67,3,1,2,3,4,5,6,68,98,99,76,65,66,33,43,32,43};
        int[] num4=new int[]{3,45,89,53,12,19,6,20,75,66,90,30,67,3,1,2,3,4,5,6,68,98,99,76,65,66,33,43,32,43};

        System.out.println("冒泡排序1(原始版)");
        sort1(num);
        System.out.println("冒泡排序2(递归版1)");
        sort2(num1);
        System.out.println("冒泡排序3(递归版2)");
        sort3(num2);
        System.out.println("冒泡排序4(优化版)");
        sort4(num3);
        System.out.println("冒泡排序5(升级版)");
        sort5(num4);
    }
public static void swap(int[] num,int i,int j){
        int c=num[j];
        num[j]=num[i];
        num[i]=c;
    }

冒泡排序1(原始版)

//冒泡排序1
    public static void sort1(int[] num){
        if(num==null||num.length<2)return;
        int count=0;
        int count1=0;

        for (int i = 0; i < num.length; i++) {
            for (int j = 0; j < num.length; j++) {
                count1++;
                if (num[i] < num[j]) {
                    swap(num,i,j);
                    count++;
                }
            }
            for (int m = 0; m < num.length; m++) {
                System.out.print(num[m]+",");
            }
            System.out.println();
        }
        System.out.println("调用交换函数swap次数"+count);
        System.out.println("循环次数"+count1);
    }

运行结果：

冒泡排序1(原始版)
99,3,45,53,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,99,45,53,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,45,99,53,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,45,53,99,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,12,45,53,99,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,12,19,45,53,99,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,6,12,19,45,53,99,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,6,12,19,20,45,53,99,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,6,12,19,20,45,53,75,99,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,6,12,19,20,45,53,66,75,99,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,6,12,19,20,45,53,66,75,89,99,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,6,12,19,20,30,45,53,66,75,89,99,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,6,12,19,20,30,45,53,66,67,75,89,99,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
3,3,6,12,19,20,30,45,53,66,67,75,89,99,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
1,3,3,6,12,19,20,30,45,53,66,67,75,89,99,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
1,2,3,3,6,12,19,20,30,45,53,66,67,75,89,99,3,4,5,6,68,90,98,76,65,66,33,43,32,43,
1,2,3,3,3,6,12,19,20,30,45,53,66,67,75,89,99,4,5,6,68,90,98,76,65,66,33,43,32,43,
1,2,3,3,3,4,6,12,19,20,30,45,53,66,67,75,89,99,5,6,68,90,98,76,65,66,33,43,32,43,
1,2,3,3,3,4,5,6,12,19,20,30,45,53,66,67,75,89,99,6,68,90,98,76,65,66,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,45,53,66,67,75,89,99,68,90,98,76,65,66,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,45,53,66,67,68,75,89,99,90,98,76,65,66,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,45,53,66,67,68,75,89,90,99,98,76,65,66,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,45,53,66,67,68,75,89,90,98,99,76,65,66,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,45,53,66,67,68,75,76,89,90,98,99,65,66,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,45,53,65,66,67,68,75,76,89,90,98,99,66,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,45,53,65,66,66,67,68,75,76,89,90,98,99,33,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,33,45,53,65,66,66,67,68,75,76,89,90,98,99,43,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,33,43,45,53,65,66,66,67,68,75,76,89,90,98,99,32,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,45,53,65,66,66,67,68,75,76,89,90,98,99,43,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
调用交换函数swap次数196
循环次数900

冒泡排序2(递归版1)

//冒泡排序2
    public static void sort2(int[] num){
        if(num==null||num.length<2)return;
        int count=0;
        int count1=0;

        for (int i = num.length-1; i >0; i--) {
            for (int j = 0; j < i; j++) {
                count1++;
                if (num[i] < num[j]) {
                    swap(num,i,j);
                    count++;
                }
            }

            for (int m = 0; m < num.length; m++) {
                System.out.print(num[m]+",");
            }
            System.out.println();
        }
        System.out.println("调用交换函数swap次数"+count);
        System.out.println("循环次数"+count1);
    }

运行结果：

冒泡排序2(递归版1)
3,43,45,53,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,99,
3,32,43,45,12,19,6,20,53,66,75,30,67,3,1,2,3,4,5,6,68,89,90,76,65,66,33,43,98,99,
3,32,43,43,12,19,6,20,45,53,66,30,67,3,1,2,3,4,5,6,68,75,89,76,65,66,33,90,98,99,
3,32,33,43,12,19,6,20,43,45,53,30,66,3,1,2,3,4,5,6,67,68,75,76,65,66,89,90,98,99,
3,32,33,43,12,19,6,20,43,45,53,30,66,3,1,2,3,4,5,6,66,67,68,75,65,76,89,90,98,99,
3,32,33,43,12,19,6,20,43,45,53,30,65,3,1,2,3,4,5,6,66,66,67,68,75,76,89,90,98,99,
3,32,33,43,12,19,6,20,43,45,53,30,65,3,1,2,3,4,5,6,66,66,67,68,75,76,89,90,98,99,
3,32,33,43,12,19,6,20,43,45,53,30,65,3,1,2,3,4,5,6,66,66,67,68,75,76,89,90,98,99,
3,32,33,43,12,19,6,20,43,45,53,30,65,3,1,2,3,4,5,6,66,66,67,68,75,76,89,90,98,99,
3,32,33,43,12,19,6,20,43,45,53,30,65,3,1,2,3,4,5,6,66,66,67,68,75,76,89,90,98,99,
3,6,32,33,12,19,6,20,43,43,45,30,53,3,1,2,3,4,5,65,66,66,67,68,75,76,89,90,98,99,
3,5,6,32,12,19,6,20,33,43,43,30,45,3,1,2,3,4,53,65,66,66,67,68,75,76,89,90,98,99,
3,4,5,6,12,19,6,20,32,33,43,30,43,3,1,2,3,45,53,65,66,66,67,68,75,76,89,90,98,99,
3,3,4,5,6,12,6,19,20,32,33,30,43,3,1,2,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
2,3,3,4,5,6,6,12,19,20,32,30,33,3,1,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,4,5,6,6,12,19,20,30,32,3,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
调用交换函数swap次数89
循环次数435

冒泡排序3(递归版2) 

public static void sort3(int[] num) {
        if (num == null || num.length < 2) return;
        int count = 0;
        int count1 = 0;
        for (int i = num.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                count1++;
                if (num[j] > num[j + 1]) {
                    swap(num, j, j + 1);
                    count++;
                }
            }

            for (int m = 0; m < num.length; m++) {
                System.out.print(num[m] + ",");
            }
            System.out.println();
        }
        System.out.println("调用交换函数swap次数"+count);
        System.out.println("循环次数"+count1);
    }

运行结果：

冒泡排序3(递归版2)
3,45,53,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,99,
3,45,12,19,6,20,53,66,75,30,67,3,1,2,3,4,5,6,68,89,90,76,65,66,33,43,32,43,98,99,
3,12,19,6,20,45,53,66,30,67,3,1,2,3,4,5,6,68,75,89,76,65,66,33,43,32,43,90,98,99,
3,12,6,19,20,45,53,30,66,3,1,2,3,4,5,6,67,68,75,76,65,66,33,43,32,43,89,90,98,99,
3,6,12,19,20,45,30,53,3,1,2,3,4,5,6,66,67,68,75,65,66,33,43,32,43,76,89,90,98,99,
3,6,12,19,20,30,45,3,1,2,3,4,5,6,53,66,67,68,65,66,33,43,32,43,75,76,89,90,98,99,
3,6,12,19,20,30,3,1,2,3,4,5,6,45,53,66,67,65,66,33,43,32,43,68,75,76,89,90,98,99,
3,6,12,19,20,3,1,2,3,4,5,6,30,45,53,66,65,66,33,43,32,43,67,68,75,76,89,90,98,99,
3,6,12,19,3,1,2,3,4,5,6,20,30,45,53,65,66,33,43,32,43,66,67,68,75,76,89,90,98,99,
3,6,12,3,1,2,3,4,5,6,19,20,30,45,53,65,33,43,32,43,66,66,67,68,75,76,89,90,98,99,
3,6,3,1,2,3,4,5,6,12,19,20,30,45,53,33,43,32,43,65,66,66,67,68,75,76,89,90,98,99,
3,3,1,2,3,4,5,6,6,12,19,20,30,45,33,43,32,43,53,65,66,66,67,68,75,76,89,90,98,99,
3,1,2,3,3,4,5,6,6,12,19,20,30,33,43,32,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,33,32,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
调用交换函数swap次数192
循环次数435

冒泡排序4(优化版)

 //冒泡排序4
    public static void sort4(int[] num){
        if(num==null||num.length<2)return;
        int count=0;
        int count1=0;

        for (int i = 0; i < num.length-1; i++) {
            boolean flag=true;

            for (int j = 0; j < num.length-i-1; j++) {
                count1++;
                if (num[j+1] < num[j]) {
                    flag=false;
                    swap(num,j,j+1);
                    count++;
                }
            }
            if(flag)break;
            for (int m = 0; m < num.length; m++) {
                System.out.print(num[m]+",");
            }
            System.out.println();
        }
        System.out.println("调用交换函数swap次数"+count);
        System.out.println("循环次数"+count1);
    }

运行结果：

冒泡排序4(优化版)
3,45,53,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,99,
3,45,12,19,6,20,53,66,75,30,67,3,1,2,3,4,5,6,68,89,90,76,65,66,33,43,32,43,98,99,
3,12,19,6,20,45,53,66,30,67,3,1,2,3,4,5,6,68,75,89,76,65,66,33,43,32,43,90,98,99,
3,12,6,19,20,45,53,30,66,3,1,2,3,4,5,6,67,68,75,76,65,66,33,43,32,43,89,90,98,99,
3,6,12,19,20,45,30,53,3,1,2,3,4,5,6,66,67,68,75,65,66,33,43,32,43,76,89,90,98,99,
3,6,12,19,20,30,45,3,1,2,3,4,5,6,53,66,67,68,65,66,33,43,32,43,75,76,89,90,98,99,
3,6,12,19,20,30,3,1,2,3,4,5,6,45,53,66,67,65,66,33,43,32,43,68,75,76,89,90,98,99,
3,6,12,19,20,3,1,2,3,4,5,6,30,45,53,66,65,66,33,43,32,43,67,68,75,76,89,90,98,99,
3,6,12,19,3,1,2,3,4,5,6,20,30,45,53,65,66,33,43,32,43,66,67,68,75,76,89,90,98,99,
3,6,12,3,1,2,3,4,5,6,19,20,30,45,53,65,33,43,32,43,66,66,67,68,75,76,89,90,98,99,
3,6,3,1,2,3,4,5,6,12,19,20,30,45,53,33,43,32,43,65,66,66,67,68,75,76,89,90,98,99,
3,3,1,2,3,4,5,6,6,12,19,20,30,45,33,43,32,43,53,65,66,66,67,68,75,76,89,90,98,99,
3,1,2,3,3,4,5,6,6,12,19,20,30,33,43,32,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,33,32,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
调用交换函数swap次数192
循环次数344

冒泡排序5(升级版)

//冒泡排序升级版
    public static void sort5(int[] arr){
        if(arr==null||arr.length<2)return;
        int count=0;
        int count1=0;
        int Index = 0;
        int Border = arr.length - 1;

        for (int i = 0; i < arr.length - 1; i++) {
            boolean isSorted  = true;//有序标记，每一轮的初始是true
            for (int j = 0; j < Border; j++) {
                count1++;
                if (arr[j + 1] < arr[j]) {
                    isSorted  = false;//有元素交换，所以不是有序，标记变为false
                    swap(arr,j,j+1);
                    count++;
                    Index = j;
                }
            }
            for (int m = 0; m < arr.length; m++) {
                System.out.print(arr[m]+",");
            }
            System.out.println();
            Border = Index;
            //一趟下来是否发生位置交换，如果没有交换直接跳出大循环
            if(isSorted )  break;
        }

        System.out.println("调用交换函数swap次数"+count);
        System.out.println("循环次数"+count1);
    }

运行结果：

冒泡排序5(升级版)
3,45,53,12,19,6,20,75,66,89,30,67,3,1,2,3,4,5,6,68,90,98,76,65,66,33,43,32,43,99,
3,45,12,19,6,20,53,66,75,30,67,3,1,2,3,4,5,6,68,89,90,76,65,66,33,43,32,43,98,99,
3,12,19,6,20,45,53,66,30,67,3,1,2,3,4,5,6,68,75,89,76,65,66,33,43,32,43,90,98,99,
3,12,6,19,20,45,53,30,66,3,1,2,3,4,5,6,67,68,75,76,65,66,33,43,32,43,89,90,98,99,
3,6,12,19,20,45,30,53,3,1,2,3,4,5,6,66,67,68,75,65,66,33,43,32,43,76,89,90,98,99,
3,6,12,19,20,30,45,3,1,2,3,4,5,6,53,66,67,68,65,66,33,43,32,43,75,76,89,90,98,99,
3,6,12,19,20,30,3,1,2,3,4,5,6,45,53,66,67,65,66,33,43,32,43,68,75,76,89,90,98,99,
3,6,12,19,20,3,1,2,3,4,5,6,30,45,53,66,65,66,33,43,32,43,67,68,75,76,89,90,98,99,
3,6,12,19,3,1,2,3,4,5,6,20,30,45,53,65,66,33,43,32,43,66,67,68,75,76,89,90,98,99,
3,6,12,3,1,2,3,4,5,6,19,20,30,45,53,65,33,43,32,43,66,66,67,68,75,76,89,90,98,99,
3,6,3,1,2,3,4,5,6,12,19,20,30,45,53,33,43,32,43,65,66,66,67,68,75,76,89,90,98,99,
3,3,1,2,3,4,5,6,6,12,19,20,30,45,33,43,32,43,53,65,66,66,67,68,75,76,89,90,98,99,
3,1,2,3,3,4,5,6,6,12,19,20,30,33,43,32,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,33,32,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
1,2,3,3,3,4,5,6,6,12,19,20,30,32,33,43,43,45,53,65,66,66,67,68,75,76,89,90,98,99,
调用交换函数swap次数192
循环次数342

留言：为作者一人拙见，仅参看使用，如有帮助，不甚荣幸。

爱打辅助的小可爱
关注
专栏目录
冒泡排序详解
学而时‘享’之，乐乎
04-01 1619
一、冒泡排序介绍 冒泡排序是一种基于比较和交换操作的排序算法。 每轮冒泡的过程都是从第一个元素开始，将该元素和相邻下一个元素进行比较和交换，使得较大的元素向右移动（如果该元素大于下一个元素，则两个元素交换；如果该元素小于等于下一个元素，则保持不变）。这样一来，每轮冒泡的过程都可以确定一个元素放在正确的位置上，而这个元素就是剩余元素中最大的元素，正确的位置就是剩余位置中的最右侧的位置。这个过程就像是...
JS-算法：冒泡排序
chushu4289的博客
10-15 961
算法基本思想： 1、比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。 2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。 3、针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。 4、持续每次对越来越少的元...
排序算法之冒泡排序详细解读（附带Java代码解读）
最新发布
m0_61840987的博客
08-26 1158
冒泡排序详细解读（附带简单Java代码解读）详细讲解实现原理
<菜鸟学算法-A排序（冒泡排序)>
braveboyny的专栏
05-20 568
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。 #include void bubble_sort(int *a,int
冒泡排序的几种方法
wr8023nt的博客
01-28 380
一、sort for循环 #include #define size 10  //宏定义 int main() {  int a[size] = {0};  int i, j, tmp;  printf("please input \n");  for(i = 0; i  {   scanf("%d", &a[i]);                 //输入i个数
c++冒泡排序详解
12-26
说一说冒泡排序 冒泡排序，作为最基本的排序算法，由于原理像冒泡一样，所以取名为冒泡排序； 我们知道，水泡在上升时，总是密度最小的最先上去，假如一个水层只能容纳一个水泡，那么水泡由上到下的排序就是密度逐渐...
详解Java冒泡排序
08-27
冒泡排序是一种简单的排序算法，它的基本思想是通过重复遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这...
JS排序之冒泡排序详解
12-02
冒泡排序是一种基础且经典的排序算法，主要应用于JavaScript等编程语言中。它的基本思想是通过重复遍历待排序的数列，一次比较两个相邻的元素，如果它们的顺序（如从小到大）错误就把它们交换过来。遍历数列的工作是...
冒泡排序详解–python
12-21
冒泡排序是一种基础且经典的排序算法，它的基本思想是通过重复遍历待排序的数列，依次比较相邻的两个元素并根据需要交换位置，使得每一遍遍历后，最大的元素都会“浮”到数列的末尾，就像水底下的气泡逐渐上升至水面...
Java中的经典算法之冒泡排序(Bubble Sort)
weixin_33875564的博客
04-22 252
Java中的经典算法之冒泡排序(BubbleSort) SiberiaDante的博客主页 原理：比较两个相邻的元素，将值大的元素交换至右端。 思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全...
冒泡排序
游离子丶
08-10 1415
太久没自己写排序了，今天本来想手写一个，竟然连快排都写不出来了。好吧，所以于是打算把常用的排序全部整理一遍，首先是冒泡排序。 冒泡排序顾名思义，像池塘里的泡泡一样往上浮。以升序序列为例，冒泡排序每次就是把最小的往序列前面走，或者把最大的往序列后面走。 先贴上代码： package com.test.demo; import java.util.Scanner; public clas...
冒泡排序的三种实现方法（逐层优化）和选择法排序
m0_74343467的博客
04-02 931
冒泡排序的三种实现方法（逐层优化）和选择法排序
【排序算法】冒泡排序的三种方法
weixin_41498246的博客
05-10 332
冒泡排序算法的最优时间复杂度为n，即当且只当元素本身就是按照从小到大的顺序排列的（这里默认冒泡排序从小到大排列）。当其中有任何一组数据不是按照从小到大排列，那么时间复杂度就是o(n^2). #include<iostream> using namespace std; void print_array(int* array, int length) { cout << "array:" << endl; for (int i = 0; i < length; i
冒泡排序（超详细图解加代码解析，5分钟看懂）
热门推荐
纪宁的博客
06-02 2万+
冒泡排序算法
冒泡排序的三种形式
CodePanda@GPF的博客
07-08 904
基本思想 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 以升序为例，外层循环第一次结束以后，最大的元素冒到最后一个位置，外层循环第二次结束以后，次大的元素冒到倒数第2个位置 形式一 public voi
细说冒泡排序及其五种优化算法
少年
11-22 2529
​01冒泡排序 冒泡排序算法思想简单来说：在内层一次遍历中，arr[j] 与 arr[j - 1] 进行比较，如arr[j - 1] < arr[j], 不改变，反之互换值，保证arr[j]存储着 0~j - 1中的最大值，随一次遍历当前数组最大值也下沉至末尾，经过n - 1次外层循环，可使n - 1个元素下沉，最后一个元素位置确定，排序完成。 举个例子方便理解， 例1：例如原数组为：0，34，66，12，100，98 进入第一次冒泡排序： ...
冒泡排序的多种方法
aa10531239的专栏
06-19 465
冒泡排序算法的思想:很简单,每次遍历完序列都把最大(小)的元素放在最前面,然后再对剩下的序列从父前面的一个过程,每次遍历完之后待排序序列就少一个元素,当待排序序列减小为只有一个元素的时候排序就结束了.因此,复杂度在最坏的情况下是O(N ^ 2). [cpp] view plaincopy void  Swap( int   * a,  int   * b)    {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱打辅助的小可爱

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

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

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

打赏作者

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

抵扣说明：

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

余额充值