怎样理解冒泡排序

小涛_foxiaotao 小涛_foxiaotao 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 400+累计阅读 440平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄14年
关注
原创 最新推荐文章于 2026-03-30 22:23:48 发布 440 阅读 AI 写同款· GEO 优化 ›
图文解释冒泡排序 冒泡排序(Bubble Sort)，又被称为气泡排序或泡沫排序。它会遍历若干次需要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列的末尾！ 采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此操作，直到整个数列都有序为止！ 阅读详情

一.什么是冒泡排序

1.不断比较两个相邻元素,将大的往后或者往前排,就像水里的泡泡一样,越往后越接近水面泡泡体积越大,由此得名.

用图来说明:

冒泡排序

2.用java代码实现冒泡排序


    // ============================= 第0版 开始 ======================
    @Test
    public void sort01() {
        int []arr = {1, 2, 5, 6, 22, 23, 50, 43, 65, 78, 88};
        System.out.println("原始数组:" + Arrays.toString(arr) + ",数组长度" +arr.length);
        System.out.println("第0版 冒泡排序");
        firstBubbleSort0(arr);
        System.out.println("排序后数组" + Arrays.toString(arr));
    }
    

    /**
     * 普通版 第0版冒泡
     * @param array
     */
    private void firstBubbleSort0(int[] array) {
        int ifTimes = 0;
        int swapTimes = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length -1; j++) {
                // if次数
                ifTimes ++;

                if (array[j] > array[j+1]) {
                    int temp;
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    swapTimes ++ ;
                }
            }
            System.out.println("第" + i+ "次后结果为:" + Arrays.toString(array));
        }
        System.out.println("if判断次数ifTimes = " + ifTimes);
        System.out.println("发生交换次数swapTimes = " + swapTimes);

    }
    // ============================= 第0版 结束 ======================

原始数组:[1, 2, 5, 6, 22, 23, 50, 43, 65, 78, 88]数组长度11
第0版 冒泡排序
第0次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第1次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第2次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第3次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第4次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第5次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第6次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第7次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第8次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第9次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第10次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
if判断次数ifTimes = 110
发生交换次数swapTimes = 1
排序后数组[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]

可以看出冒泡排序的空间复杂度为O(1),时间负责度为O(n^2)

3.对于每轮排出来的最后(大)元素,其实可以不参与接下来的排序

一起来看看代码实现(在内部循环中每次遍历终点 array.length - i,i为外层循环 ) 


    // ============================= 第一版 开始 ======================
    @Test
    public void testUnSortArray() {
        int []arr = {43, 22, 6, 5, 23, 2, 50, 65, 78, 88, 1};
        System.out.println("原始数组:" + Arrays.toString(arr));
        firstBubbleSort(arr);
        System.out.println("排序后数组" + Arrays.toString(arr));
    }


    /**
     * 普通版 第一版冒泡
     * @param array
     */
    private void firstBubbleSort(int[] array) {
        int ifTimes = 0;
        int swapTimes = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length -i -1; j++) {
                // if次数
                ifTimes ++;

                if (array[j] > array[j+1]) {
                    int temp;
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    swapTimes ++ ;
                }
            }
            System.out.println("第" + i+ "次后结果为:" + Arrays.toString(array));
        }
        System.out.println("ifTimes = " + ifTimes);
        System.out.println("swapTimes = " + swapTimes);

    }

打印结果:

原始数组:[43, 22, 6, 5, 23, 2, 50, 65, 78, 88, 1]
第0次后结果为:[22, 6, 5, 23, 2, 43, 50, 65, 78, 1, 88]
第1次后结果为:[6, 5, 22, 2, 23, 43, 50, 65, 1, 78, 88]
第2次后结果为:[5, 6, 2, 22, 23, 43, 50, 1, 65, 78, 88]
第3次后结果为:[5, 2, 6, 22, 23, 43, 1, 50, 65, 78, 88]
第4次后结果为:[2, 5, 6, 22, 23, 1, 43, 50, 65, 78, 88]
第5次后结果为:[2, 5, 6, 22, 1, 23, 43, 50, 65, 78, 88]
第6次后结果为:[2, 5, 6, 1, 22, 23, 43, 50, 65, 78, 88]
第7次后结果为:[2, 5, 1, 6, 22, 23, 43, 50, 65, 78, 88]
第8次后结果为:[2, 1, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第9次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第10次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
if判断次数ifTimes = 55
发生交换次数swapTimes = 22
排序后数组[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]

时间复杂度为O(n*(n-1)/2)

冒泡排序就算完成了,好了你已经完全掌握了冒泡排序.(如果你真这样想,那你就天真了,文章也应该结束了).

二.冒泡排序优化

1.如果原来的数组接近完全排序

假如数组:

1, 2, 5, 6, 22, 23, 50, 43, 65, 78, 88
当第一轮排序完成后,得到结果

1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88

2.如果还是使用原始的冒泡排序(第一版)

原始数组:[1, 2, 5, 6, 22, 23, 50, 43, 65, 78, 88]
第一版 冒泡排序
第0次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第1次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第2次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第3次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第4次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第5次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第6次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第7次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第8次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第9次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
第10次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]
if判断次数ifTimes = 55
发生交换次数swapTimes = 1
排序后数组[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]

我们发现第0次遍历后,数组已经是完全排序.后面的遍历其实没有必要.

3.来了来了,第二版代码

每次内部循环完之后,判断数组是否已经是有序状态

     // ============================= 第二版 ======================
    @Test
    public void sort22() {
        int []arr = {1, 2, 5, 6, 22, 23, 50, 43, 65, 78, 88};
        System.out.println("原始数组:" + Arrays.toString(arr));
        System.out.println("第二版 冒泡排序(如果数组已经有序,结束排序)");
        sortArrayWithAllArrayIsSorted(arr);
        System.out.println("排序后数组" + Arrays.toString(arr));
    }

    /**
     * 对已经排序的  可以减少开销, 当数组已经是排序状态后 不会继续进行
     * 判断目标是 整个 数组是否已经排序好
     * @param array
     */
    private void sortArrayWithAllArrayIsSorted(int[] array) {
        int ifTimes = 0;
        int swapTimes = 0;

        for (int i = 0; i < array.length; i++) {
            // 是否已经排序好了(是否发生互换 否定)
            boolean isSorted = true;
            for (int j = 0; j < array.length - 1 - i ; j++) {
                // if次数
                ifTimes ++;

                if (array[j] > array[j+1]) {
                    int temp;
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    isSorted = false;
                    swapTimes ++ ;
                }
            }
            System.out.println("第" + i+ "次后结果为:" + Arrays.toString(array) + ",isSorted=" + isSorted);
            // 如果没有互换 说明已经排序完成
            if (isSorted) {
                break;
            }
        }
        System.out.println("if判断次数ifTimes = " + ifTimes);
        System.out.println("发生交换次数swapTimes = " + swapTimes);
    }


    // ============================= 第二版 结束 ======================

3.1 使用该代码排序接近排序的数组

原始数组:[1, 2, 5, 6, 22, 23, 50, 43, 65, 78, 88]
第二版 冒泡排序(如果数组已经有序,结束排序)
第0次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第1次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=true
if判断次数ifTimes = 19
发生交换次数swapTimes = 1
排序后数组[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]

这种接近完全排序的数组,在这种情况下优势明显.

3.2 如果数组不是接近完全排序

使用第二版 冒泡排序,排序下列数组

原始数组:[2, 5, 6, 1, 22, 23, 43, 50, 65, 78, 88]
第0次后结果为:[2, 5, 1, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第1次后结果为:[2, 1, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第2次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第3次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=true
if判断次数ifTimes = 34
发生交换次数swapTimes = 3
[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]

相比较于第一版,还是减少了很多遍历比较次数.

4.如果数组部分有序,只需要遍历无序部分.

观察3.2中例子, 数组中 22, 23, 43, 50, 65, 78, 88 部分不需要排序,那么遍历的时候能不能把这部分排除呢?

所以咱们第三版排序,在第二版的基础上考虑部分有序,遍历到无序 和 有序的分界处就可以了.

上菜:

    @Test
    public void sort32() {
        int []arr = {2, 5, 6, 1, 22, 23, 43, 50, 65, 78, 88};
        System.out.println("原始数组:" + Arrays.toString(arr));
        System.out.println("第三版 冒泡排序(遍历到无序和有序的边界)");
        sortArrayWithPartyArrayIsSorted(arr);
        System.out.println("排序后数组" + Arrays.toString(arr));
    }

    /**
     * 遍历到无序和有序的边界
     * 判断目标是 部分(前半无序,后半有序 会减少if) 
     * @param array
     */
    private void sortArrayWithPartyArrayIsSorted(int[] array) {

        int ifTimes = 0;
        int swapTimes = 0;

        // 最后一次发生交换的地方
        int lastSwapIndex = 0;

        // 无序部分长度, 每次比较只需要比到这里为止
        int unSortBorder = array.length -1;

        for (int i = 0; i < array.length; i++) {
            // 是否已经排序好了(是否发生互换 否定)
            boolean isSorted = true;
            for (int j = 0; j < unSortBorder; j++) {
                // for次数
                ifTimes ++;

                if (array[j] > array[j+1]) {
                    int temp;
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;

                    isSorted = false;
                    // 当本轮for完成 j 到 array.length 的位置元素已经排序,下轮不需要遍历
                    lastSwapIndex = j;

                    swapTimes ++ ;
                }
            }
            System.out.println("第" + i+ "次后结果为:" + Arrays.toString(array) + ",isSorted=" + isSorted);
            // 如果没有互换 说明已经排序完成
            // 更新边界
            unSortBorder = lastSwapIndex;

            if (isSorted) {
                break;
            }

        }
        System.out.println("if判断次数ifTimes = " + ifTimes);
        System.out.println("发生交换次数swapTimes = " + swapTimes);
    }
    // ============================= 第三版 结束 ======================

原始数组:[2, 5, 6, 1, 22, 23, 43, 50, 65, 78, 88]
第三版 冒泡排序(遍历到无序和有序的边界)
第0次后结果为:[2, 5, 1, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第1次后结果为:[2, 1, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第2次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第3次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=true
if判断次数ifTimes = 13
发生交换次数swapTimes = 3
排序后数组[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88]

和例子3.2中同样的数组,减少了21次if判断.

5.刚刚我们只考虑了数组的一边是否有边界(有序无序边界),我们能不能考虑数组两边是否有边界呢

思路:i是偶数从左到右冒大泡, 如果i是基数 从右到左冒小泡.

    // 第四版(考虑双向边界)
    @Test
    public void sort43() {
        int []arr = {2, 5, 6, 22, 23, 43, 50, 65, 78, 88, 1};
        sortArrayWithDoublePartyArrayIsSorted(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 对已经排序的  可以减少开销, 当数组已经是排序状态后 不会继续进行
     * 判断目标是 双边界(从两边观察 是否有已经排好序的部分) 数组是否已经排序好
     * @param array
     */
    private void sortArrayWithDoublePartyArrayIsSorted(int[] array) {
        int temp;
        int ifTimes = 0;
        int swapTimes = 0;

        // 最后一次发生交换的地方
        int lastLeftSwapIndex = 0;
        int lastRightSwapIndex = array.length -1;

        for (int i = 0; i < array.length; i++) {
            // 是否已经排序好了(是否发生互换 否定)
            boolean isSorted = true;

            // 每次从第个开始判断if
            int beginBorder = lastLeftSwapIndex;
            // 无序部分长度, 每次比较只需要比到这里为止
            int endBorder = lastRightSwapIndex;

            if(i % 2 == 0) {
                for (int j = beginBorder; j < endBorder; j++) {
                    // if次数
                    ifTimes ++;
                    //
                    if (array[j] > array[j+1]) {
                        temp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = temp;

                        isSorted = false;
                        // 当本轮for完成 j 到 array.lenght 的位置元素已经排序
                        lastRightSwapIndex = j;

                        // test 代码
                        swapTimes ++ ;
                    }
                }
            } else {
                for (int j = endBorder - 1; j >= 0; j--) {
                    // if次数
                    ifTimes++;
                    //
                    if (array[j] > array[j + 1]) {
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;

                        isSorted = false;
                        // 当本轮for完成 endBorder - j 到 endBorder 的位置元素已排序排序
                        lastLeftSwapIndex = j;

                        // test 代码
                        swapTimes++;
                    }
                }
            }
            System.out.println("第" + i+ "次后结果为:" + Arrays.toString(array) + ",isSorted=" + isSorted);

            // 如果没有互换 说明已经排序完成
            if (isSorted) {
                break;
            }
        }
        System.out.println("if判断次数ifTimes = " + ifTimes);
        System.out.println("发生交换次数swapTimes = " + swapTimes);
    }

以数组:[ 2, 5, 6, 22, 23, 43, 50, 65, 78, 88, 1 ] 为例

第三版结果:

原始数组:[2, 5, 6, 22, 23, 43, 50, 65, 78, 88, 1]
第三版 冒泡排序(遍历到无序和有序的边界)
第0次后结果为:[2, 5, 6, 22, 23, 43, 50, 65, 78, 1, 88],isSorted=false
第1次后结果为:[2, 5, 6, 22, 23, 43, 50, 65, 1, 78, 88],isSorted=false
第2次后结果为:[2, 5, 6, 22, 23, 43, 50, 1, 65, 78, 88],isSorted=false
第3次后结果为:[2, 5, 6, 22, 23, 43, 1, 50, 65, 78, 88],isSorted=false
第4次后结果为:[2, 5, 6, 22, 23, 1, 43, 50, 65, 78, 88],isSorted=false
第5次后结果为:[2, 5, 6, 22, 1, 23, 43, 50, 65, 78, 88],isSorted=false
第6次后结果为:[2, 5, 6, 1, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第7次后结果为:[2, 5, 1, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第8次后结果为:[2, 1, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第9次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第10次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=true
if判断次数ifTimes = 55
发生交换次数swapTimes = 10

第四版结果:

原始数组:[2, 5, 6, 22, 23, 43, 50, 65, 78, 88, 1]
第四版 冒泡排序(考虑双向边界)
第0次后结果为:[2, 5, 6, 22, 23, 43, 50, 65, 78, 1, 88],isSorted=false
第1次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=false
第2次后结果为:[1, 2, 5, 6, 22, 23, 43, 50, 65, 78, 88],isSorted=true
if判断次数ifTimes = 28
发生交换次数swapTimes = 10

第四版结果明显优于第三版结果,但是第四版缺点就是代码量复杂.

git代码:https://github.com/foxiaotao/java_interview/tree/master/src/sort/bubble

收录于
算法

当前文章被收录于：

算法
4 篇文章 0 人学习
订阅专栏 查看详情
标签
#冒泡排序 #冒泡排序优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
冒泡排序 理解 1. 什么是冒泡排序？ 冒泡排序是一种较简单的排序算法。因为在算法过程中，最大的数会慢慢“浮”到数列顶端，就像泡泡一样慢慢浮上去，所以叫冒泡排序。 2. 冒泡排序的思路 举个例子，有一群人，站成一排，我们要把他们按个子从高到矮排序，我们会把个子最高的人挑出来，让他站最前面，然后把剩下人里面个子最高的挑出来站刚刚那个人后面，继续这样挑下去直到所有人挑完了，我们的排序也就完成了。对于数组，机器无法一眼... 阅读详情

相关推荐

从CAD图纸到GIS地图：手把手教你用Global Mapper处理DWG文件（含坐标配准）

本文详细介绍了如何使用Global Mapper将CAD图纸（DWG文件）转换为GIS地图，包括坐标配准、图层与属性转换等关键步骤。通过四参数变换和控制点匹配技术，确保数据精准转换，适用于测绘、城市规划等领域。文章还提供了高级处理技巧和质量控制流程，帮助用户高效完成GIS化工作。

weixin_29196891的博客 521

冒泡排序详解

冒泡排序：简单，排序时间复杂度较高

weixin_44713306的博客 5355

计算机毕业设计springboot基于微信平台的二次元手办商场小程序【附源码】

选题背景： 随着二次元文化的兴起和普及，越来越多的人开始对二次元角色产生了浓厚的兴趣和喜爱。手办作为二次元文化的重要载体之一，成为了许多二次元爱好者收藏和展示的对象。然而，在传统的线下手办商场中，消费者往往面临着时间、空间和选择的限制。因此，基于微信平台的二次元手办商场小程序应运而生。 选题意义： 首先，基于微信平台的二次元手办商场小程序能够打破地域限制，使得用户可以随时随地通过手机进行购物。无论是在家中、上班途中还是旅行中，用户都能够方便地浏览和购买自己喜欢的手办，极大地提高了购物的便利性和灵活性。

拉期程序 452

排序算法之冒泡排序

冒泡排序故名思与就是整个过程就像气泡一样往上升，单向冒泡排序的基本思想是（假设由小到大排序）：对于给定的n个记录，从第一个记录开始依次对相邻的两个记录进行比较，当前面的记录大于后面的记录时，交换位置，进行一轮比较和换位后，n个记录的最大值记录将位于第n位；然后对前（n-1）个记录进行第二轮比较；重复该过程直到进行比较的记录只剩下一个位置。

阿水的博客 2501

Simulink Test Sequence自动化测试实战：从Excel到模型验证

本文详细介绍了如何利用Excel和MATLAB脚本实现Simulink Test Sequence的自动化测试。通过设计结构化Excel模板管理测试数据，并调用Simulink Test API批量创建与执行测试用例，该方法能显著提升复杂模型单元测试的效率，便于集成到CI/CD流程，实现从数据到验证的全自动化。

weixin_29261711的博客 144

PCB线路板的制作工艺流程分享！2021-08-21

Pcb板制作工艺流程：开料-钻孔-沉铜-压膜-曝光-显影-电铜-电锡-退膜-蚀刻-退锡-光学检测-印阻焊油-阻焊曝光、显影-字符-表面处理-成型-电测-终检-抽测-包装。具体如下：1、开料（CUT） 将原始的覆铜板切割成可以用在生产线上制作的板子过程2、钻孔 使PCB板层间产生通孔，以达到连通层间的目的。 3、沉铜 经过钻孔后的线路板在沉铜缸内会发生氧化还原反应，形成铜层对孔进行孔金属化,使原来绝缘的基材表面沉积上铜,达到层间电性相通。 4、压膜 压膜后的PCB板上面压了一层蓝色的干膜, 干膜是一个载体

jdbpcb88的博客 3246

冒泡排序理解

这里写自定义目录标题冒泡排序理解 冒泡排序理解 冒泡排序通过每个元素都与其他元素比较一遍的方式，将数组中的元素按照从小到大或者从大到小的方式重新排序 具体的比较规可以这么理解 外循环循环变量每+1,就将剩余元素中最大的值找出来放到元素的最后边 先写出代码 let numbers=[22,3,4] for(var i=0;i<numbers.length-1;i++){ for(var j=0;j<numbers.length-1-i;j++){

csdn姚宏波 444

3.嵌入式控制器EC学习，源码框架（60/64端口）（一）

服务函数剖析 上一篇讲到while循环会一直查询十六个标志位是否满足要求，一旦其中某个标志位为1时，程序将会执行相应的服务函数，而执行服务函数是通过函数指针(service_table[ _R1 ])();来实现的。接下来我们分别来看看这十六个服务函数分别包含了哪些内容。 16个函数的函数名如下： const FUNCT_PTR_V_V code service_table[16] = { // Hi-Level Service Service_PCI, // Host 6

qq_30135687的博客 4160

我理解的冒泡排序

package demo09; import java.util.Arrays; /** * @Author: micro cloud fly * @Description: 冒泡排序 * @Date: Created in 4:39 下午 2020/9/27 */ public class Test { public static void main(String[] args) { int[] arr = new int[]{ 1,.

silk_java的专栏 172

基于STM32L4XX、HAL库的DP83822 以太网收发器（PHY）驱动程序设计

一、简介：DP83822是德州仪器(TI)推出的一款低功耗、高性能10/100Mbps以太网物理层收发器(PHY)。它具有以下主要特性：支持10BASE-T和100BASE-TX以太网标准低功耗设计，适合嵌入式应用MII/RMII接口，方便与微控制器连接内置自检和诊断功能支持自动协商和手动配置工业级温度范围(-40°C至+85°C)

zhusl6688的博客 526

Istio ICA考试之路---2-2

找到dr部分,这部分可以在mirroring里找也可以和题2-1一样在Traffic Management的dr里复制,内容都一样。此题之后都是在cluster-2上操作,所以就不需要再切换了.之后的几题2.1节就忽略掉了。可以看到,80%的流量被镜像到了dev上,实际考试这步可以忽略。看到ex-ip是192.168.126.220。获取gw,把gateways加入到vs配置中。获取istio-ingress的ex-ip。就获得了这样一个模板文件。查看2个pod的日志。

Q先生 854

关于理解冒泡排序的经历

 我是一菜鸟新手， 学习Java 刚入门不久，最近想好好理解下冒泡排序算法，可是好像看来挺多的例子和网上的解释，好像都没有真正的理解，可能是自己在这方面没有DOWER 吧。   然后试着去用debug一步一步的调着一个冒泡排序的例子，看着每一步debug出来的结果，终于理解了这个算法。

认真做事，开心生活 639

【DexGraspNet与多指手抓取算法详解】第三章 DexGraspNet数据集构建机理

抓取姿态描述多指手与物体的相对空间关系，包含手掌位姿与手指关节配置。

VectorShift的博客 497

一篇文章让你真正理解冒泡排序

本文简明讲解冒泡排序算法，适合初学者理解。

baidu_33719384的博客 827

老版QQ原生表情gif动态

这是老版的QQ表情，不过全是动态的的，Windows照片查看器是不会动的，可以右击用浏览器打开查看，再说一遍是老版的，只是分享给宁愿用老版也要动态的人。

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

.net C#带你理解冒泡排序

相信能够搜到该文章的程序员应该多数都在面试中碰到了这个问题，其实冒泡排序也不算是太难，如果你真的想搞懂，调试去跑一边就差不多能够懂了，光靠看，里面的逻辑有的时候有点绕，包括那个递归的一个面试题也是的，代码这种东西别靠死记，要懂得理解，理解后多实践一下，这个代码就会被深深的印到你的脑子里面了 接下来上代码与解析 int[] array = { 94,33,61,1 };//定义一个需要排序的数组 for (int i = 0; i < (array.Length-1); i++

qq_40256322的博客 422

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf：最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版，包括SDIO 接口的外设，SDIO 接口官方协议等。

冒泡排序理解以及算法优化

冒泡排序理解与算法优化 冒泡排序为基本内部排序算法(即不借助外部空间,内部自我排序), 如上图,冒泡排序经过不断比较相邻的元素的值,进行交换,第一次从第一个元素到最后一个元素的交换,会将该数组的最大值交换到最后一项,以此循环,我们不断地找出剩余元素中的最大值,并将该最大值移动到剩余元素中的最大值.最终排序成功. (本文中语言使用c语言,算法利用函数实现,编译器参考DEV C++) void Bubble_sort(int *a,int len)//函数传递数组名字以及数组长度 { int i,j,k

weixin_52333983的博客 1027

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面，电脑运行连游戏界面都一样大小，很怀旧，很真实，（英文版）强烈推荐，很小的文件，很难才找到的。

冒泡排序再理解

今天重新学习这个人人皆知的算法–冒泡排序 冒泡排序 1、从头依次访问数组每个元素，进行相邻元素之间的交换 2、元素之间两两交换，把小的换到前面，大的放到后面。 3、所有元素交换完成后，一趟交换完成，此时最大的元素会到数组尾部。 4、反复执行以上步骤，直到所有元素都排序完。   这个冒泡算法基本大家都学过，本人愚笨一直也没有深入理解这个算法，往往都是记住大概的代码样子，导致过了很久完全不记得冒泡...

无痕之意的博客 2366

冒泡排序的理解

每次准备面试，都要看下冒泡算法，因为不会！工作三年多，这个算法算个试题吧，每次死记硬背，却没有理解，悲哀啊，其实也没多复杂，代码几行，第一个循环，代表比较次数，多少个数，就比较多少次-1，int i=0;i<a.length-1;i++这个是控制循环的。从第一个数开始比，比较几次呢，假如两个数，比较一次，假如三个数，二次，规律是减一，第二个循环，控制指针，从第几个数开始比，先看语法int j...

weixin_30922589的博客 102

冒泡排序理解难点的解析

如果代码标记起始的符号是1，那么你的理解没有任何问题，但是，java代码计算循环次数的符号是0,那么记录第一趟循环的标记符号是0，内层循环的次数是9，那么0+9 = 9。冒泡排序在学习过程中，很多人感觉很难学习，其实主要的难点在于内外两层循环次数的控制次数的理解，内部循环体，也就是两个相邻数据的交换并不是难于理解。如果代码标记起始的符号是1，那么记录第一趟循环的标记符号是1，内层循环的次数是9，那么1+9 = 10。难于理解的地方需要我们解释一下，java代码中重要的两行代码如下，其余的就不写了。

weixin_39357208的博客 319

冒泡排序法的理解

方便回忆： 冒泡排序法是先排序好最大的那个数字在数组最后面，再排倒数第二大的数字。。。以此类推。 void Bubble_Sort(int *num, int n) {     int i, j;     for(i = 0; i      {         for(j = 0; i + j          {             if(num[j] > 

qweasdzxcpkh的博客 2112

深入理解冒泡排序

>> 冒泡排序 冒泡排序可能非你所想。 冒泡排序的思路： 给定一个数组，每次循环出最大的数依次向后排，并将较小的数向前冒。 平均时间复杂度： O(n^2) 最好情况： O(n) 已经排好序 最坏情况： O(n^2) 倒叙的时候 空间复杂度： O(1) 没有占用额外的空间 稳定性： 稳定 排序前相等的两个数，排序后位置不变 : ） 快速排序值得注意的是：第一层循...

qq_37744360的博客 271

冒泡排序简单理解

原理 冒泡排序 人如其名 就像泡泡一样，较大的数从下面一个一个与其他数进行比较，如果依然较大则继续往上浮。 一个数列有 $n$个数字，我们每个数字循环一遍（外层循环），第i个数在最坏情况下（完全与目标结果相反）还需要交换$ n-i $次（内层循环）所以冒泡排序并不是很稳定的 最坏情况达到 $O(n^2)$ 依然不理解的话，可以手动模拟一下，其实就相当于每一轮外层循环会确定一个第n大（小）值。在 $n$轮后就是有序的了。 ## 2.2 代码 ```cpp #include <bits/std

weixin_44608143的博客 189

好记好理解的冒泡排序

给出一个数组，如何通过冒泡排序的方法进行排序？ 代码如下： package pb.com.home; public class Maopao { public static void main(String[] args) { int[] nums ={0,80,7,8,22,110}; //外层循环：轮 内层循环：每轮比较几次

qacjava的博客 331
上一篇： 延迟调度实现
下一篇： 怎样理解选择排序
点赞 0
评论 0
书签 书签 0
小涛_foxiaotao
小涛_foxiaotao
博客等级 码龄14年 2粉丝 52原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值