首页 / 算法 / 冒泡排序算法分析 - JAVA版

冒泡排序算法分析 - JAVA版

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了冒泡排序算法分析 - JAVA版，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11738字，纯文字阅读大概需要17分钟。

内容图文

工作这么久了，由于本人非科班出身，对于一些基础的算法理解一致不是很透彻。以冒泡算法为例，每次复习后，过段时间总是遗忘，又要重新看，今天索性静下心来详细分析一下，虽然是最基础的算法，然而小算法中未必没有大智慧，供本人及后来人参考。

先来看一个最笨的排序：

    public static void sort1(int[] a){
        int count = 0 ;
        for(int i=0; i<a.length; i++){
            for(int j=0; j<a.length; j++){
                count++ ;if(a[i] < a[j]){
                    int temp = a[i];
                    a[i] = a[j] ;
                    a[j] = temp ;
                }
            }
        }
        System.out.println("#sort1 forloop count - " + count);
    }

　　这是一种比较笨的排序方法，很多新人在写排序的时候，可能这样写理解会比较直观一些，将数组循环length*length次，所有值俩俩进行一次对比，最后得出结论：

    public static void main(String[] args) {
        int[] arr = new int[]{12,4,54,57,87,3,41,1,3,4,1,3,4,31,2} ;
        sort1(arr);
        System.out.println("最终结果：" + Arrays.toString(arr));
    }

结果：

#sort1 forloop count - 225
最终结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]

可见本次执行225次循环；

再来看一个升级版：

    public static void sort2(int[] a){
        int count = 0 ;
        for(int i=0; i<a.length; i++){
            for(int j=0; j<a.length-1; j++){
                count++ ;
                if(a[j] > a[j+1]){
                    int temp = a[j] ;
                    a[j] = a[j+1] ;
                    a[j+1] = temp ;
                }
            }
        }
        System.out.println("#sort2 forloop count - " + count);
    }

本方法对上一个方法进行了进一步的简化，第一层同样循环length次，而第二层循环了length-1次，同时比较只存在于第二层循环中，由于第二层的比较重，将当前下标与当前下标+1进行比较，所以总的循环数需要length-1，否则会造成数组越界，这一种算法比较常见，甚至一些培训机构对学生进行培训时也是使用这种排序算法（至于是老师水平问题还是老师考虑到学生理解能力问题采用本种方法不得而知），本方法对第二层的循环进行了-1操作，总排序次数当然要少于第一种。

执行：

int[] arr = new int[]{12,4,54,57,87,3,41,1,3,4,1,3,4,31,2} ;
sort2(arr);
System.out.println("最终结果：" + Arrays.toString(arr));

结果：

#sort2 forloop count - 210
最终结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]

本次执行210次循环，排序结果同第一种方法，效率有所提升。

对于大学没有学过算法和数据结构相关课程，又是初入开发行业的童鞋来说，本种算法可能需要分析一下才能明白原理。

我们来分析一下第二种方法的缺陷。

先看第二层循环：

每次循环，都要将第N个数与第N+1个数进行比较，如果第N个数大，则互换位置。例如：

数组：{12,4,54,3,22,53}

第一次循环，j=0，则比较12与4的大小，发现12>4，则互换12与4的位置，结果如下：

{4,12,54,3,22,53}

第二次循环，j=1，此次比较12与54的大小，发现12<54，则保持不动，结果如下：

{4,12,54,3,22,53}

第三次循环，j=2，比较54和3大小，54>3，则互换，结果如下：

{4,12,3,54,22,53}

第四次循环，j=3，比较54和22大小，54>22，互换，结果如下：

{4,12,3,22,54,53}

最后一次循环，j=4，比较54和53大小，54>53，互换，结果如下：

{4,12,3,22,53,54}

我们发现，每一次 i 循环，都可以将arr[length-1-i]这个位置的数选举而出，也就是说，整个循环只需要length-1次（最后一轮不用排序，因为剩下的最后一个数肯定是最小值），即可完成所有数的排序，所以第二个方法可进行进一步优化：

    public static void sort2_up(int[] a){
        int count = 0 ;
        for(int i=0; i<a.length-1; i++){
            for(int j=0; j<a.length-1; j++){
                count++ ;
                if(a[j] > a[j+1]){
                    int temp = 0 ;
                    temp = a[j] ;
                    a[j] = a[j+1] ;
                    a[j+1] = temp ;
                }
            }
        }
        System.out.println("#sort2_up forloop count - " + count);
    }

执行：

        int[] arr = new int[]{12,4,54,57,87,3,41,1,3,4,1,3,4,31,2} ;
        sort2_up(arr);
        System.out.println("最终结果：" + Arrays.toString(arr));

结果：

#sort2_up forloop count - 196
最终结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]

那么现在我们来看一下冒泡排序。

以上方法，第一层循环length-1次已经没有问题，那么来看下第二层循环。

每一次我们比较第j个元素和第j+1个元素，但是仔细分析，其实还是有无效比较，我们先把sort2_up中的每一次外层循环结果打印一下看看过程：

    public static void sort2_up(int[] a){
        int count = 0 ;
        for(int i=0; i<a.length-1; i++){
            for(int j=0; j<a.length-1; j++){
                count++ ;
                if(a[j] > a[j+1]){
                    int temp = 0 ;
                    temp = a[j] ;
                    a[j] = a[j+1] ;
                    a[j+1] = temp ;
                }
            }
            System.out.println("#sort2_up i="+i+", result: " + Arrays.toString(a));
        }
        System.out.println("#sort2_up forloop count - " + count);
    }

#sort2_up i=0, result: [4, 12, 54, 57, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 87]
#sort2_up i=1, result: [4, 12, 54, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 57, 87]
#sort2_up i=2, result: [4, 12, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 54, 57, 87]
#sort2_up i=3, result: [4, 3, 12, 1, 3, 4, 1, 3, 4, 31, 2, 41, 54, 57, 87]
#sort2_up i=4, result: [3, 4, 1, 3, 4, 1, 3, 4, 12, 2, 31, 41, 54, 57, 87]
#sort2_up i=5, result: [3, 1, 3, 4, 1, 3, 4, 4, 2, 12, 31, 41, 54, 57, 87]
#sort2_up i=6, result: [1, 3, 3, 1, 3, 4, 4, 2, 4, 12, 31, 41, 54, 57, 87]
#sort2_up i=7, result: [1, 3, 1, 3, 3, 4, 2, 4, 4, 12, 31, 41, 54, 57, 87]
#sort2_up i=8, result: [1, 1, 3, 3, 3, 2, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#sort2_up i=9, result: [1, 1, 3, 3, 2, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#sort2_up i=10, result: [1, 1, 3, 2, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#sort2_up i=11, result: [1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#sort2_up i=12, result: [1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#sort2_up i=13, result: [1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#sort2_up forloop count - 196
最终结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]

那么我们来看下内层循环，也就是j层循环：

每一次对第j个元素和第j+1个元素进行比较，循环length-1次。

问题出在循环length-1次上，为什么呢，因为从结果我们可以看到，其实每一轮都已经选出了一个最大值，比如第i=0次循环，选出了一个最大值，第i=1次循环，选出了除上一次最大值之外的最大值，以此类推。

也就是说，j层循环中，每次循环，后面的比较完全是多余的，多比较了多少次呢？答案是 i 次。

第一轮循环，也就是i=0，此时需要在内层比较所有元素大小，最终选举出一个最大值；当第二轮循环时，i=1，最大值已经选举出，此时已没有必要再进行最后一轮j循环，j循环层只需要执行length-1-i次即可，以此类推。

这就是冒泡循环的思想，每一轮循环，冒泡选出一个最大值，放到末尾：

    public static void bubbleSort(int[] arr) {
        int count = 0 ;
        System.out.println("待排序数组：" + Arrays.toString(arr));
        for (int i=0;i<arr.length-1;i++) {
            for (int j=0;j<arr.length-1-i;j++) {
                count++ ;
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j] ;
                    arr[j] = arr[j+1] ;
                    arr[j+1] = temp ;
                }
            }
            System.out.println("第" + (i+1) + "次排序结果：" + Arrays.toString(arr));
        }
        System.out.println("#bubbleSort forloop count - " + count);
    }

执行一下：

        int[] arr = new int[]{12,4,54,57,87,3,41,1,3,4,1,3,4,31,2} ;
        bubbleSort(arr);
        System.out.println("最终结果：" + Arrays.toString(arr));

结果：

待排序数组：[12, 4, 54, 57, 87, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2]
#第1次排序结果：[4, 12, 54, 57, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 87]
#第2次排序结果：[4, 12, 54, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 57, 87]
#第3次排序结果：[4, 12, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 54, 57, 87]
#第4次排序结果：[4, 3, 12, 1, 3, 4, 1, 3, 4, 31, 2, 41, 54, 57, 87]
#第5次排序结果：[3, 4, 1, 3, 4, 1, 3, 4, 12, 2, 31, 41, 54, 57, 87]
#第6次排序结果：[3, 1, 3, 4, 1, 3, 4, 4, 2, 12, 31, 41, 54, 57, 87]
#第7次排序结果：[1, 3, 3, 1, 3, 4, 4, 2, 4, 12, 31, 41, 54, 57, 87]
#第8次排序结果：[1, 3, 1, 3, 3, 4, 2, 4, 4, 12, 31, 41, 54, 57, 87]
#第9次排序结果：[1, 1, 3, 3, 3, 2, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第10次排序结果：[1, 1, 3, 3, 2, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第11次排序结果：[1, 1, 3, 2, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第12次排序结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第13次排序结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第14次排序结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#bubbleSort forloop count - 105
最终结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]

冒泡排序的思想，说直白点就是每次冒泡选出最大值，并且每次选出的最大值不参与下次排序。

冒泡排序的进一步优化：

上面的冒泡排序算法确实已经很高效了，但是我们仔细看输出结果，第12次、13次、14次，其排序结果相同，也就是说，实际到第12次排序已经完成，13、14次为无效操作。我们加个标记，对过程进行进一步优化：

    public static void bubbleSort_up(int[] arr) {
        int count = 0 ;
        System.out.println("待排序数组：" + Arrays.toString(arr));
        for (int i=0;i<arr.length-1;i++) {
            boolean isComplete = true ;
            for (int j=0;j<arr.length-1-i;j++) {
                count++ ;
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j] ;
                    arr[j] = arr[j+1] ;
                    arr[j+1] = temp ;
                    if (isComplete)
                        isComplete = false ;
                }
            }
            System.out.println("#第" + (i+1) + "次排序结果：" + Arrays.toString(arr));
            if (isComplete)
                break;
        }
        System.out.println("#bubbleSort_up forloop count - " + count);
    }

我们每一次外层循环开始时，记录一个完成排序标记，如果内层循环有变动，则标记为false，否则为true，看结果：

待排序数组：[12, 4, 54, 57, 87, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2]
#第1次排序结果：[4, 12, 54, 57, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 87]
#第2次排序结果：[4, 12, 54, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 57, 87]
#第3次排序结果：[4, 12, 3, 41, 1, 3, 4, 1, 3, 4, 31, 2, 54, 57, 87]
#第4次排序结果：[4, 3, 12, 1, 3, 4, 1, 3, 4, 31, 2, 41, 54, 57, 87]
#第5次排序结果：[3, 4, 1, 3, 4, 1, 3, 4, 12, 2, 31, 41, 54, 57, 87]
#第6次排序结果：[3, 1, 3, 4, 1, 3, 4, 4, 2, 12, 31, 41, 54, 57, 87]
#第7次排序结果：[1, 3, 3, 1, 3, 4, 4, 2, 4, 12, 31, 41, 54, 57, 87]
#第8次排序结果：[1, 3, 1, 3, 3, 4, 2, 4, 4, 12, 31, 41, 54, 57, 87]
#第9次排序结果：[1, 1, 3, 3, 3, 2, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第10次排序结果：[1, 1, 3, 3, 2, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第11次排序结果：[1, 1, 3, 2, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第12次排序结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#第13次排序结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]
#bubbleSort_up forloop count - 104
最终结果：[1, 1, 2, 3, 3, 3, 4, 4, 4, 12, 31, 41, 54, 57, 87]

少一次，这是因为我们这一组数字只少排序了最后一个循环，最后一次j=length-1-i，只有一次排序操作，我们换一组数来看效果：

执行：

        int[] arr = new int[]{12,4,54,57,87,3,39,40,41,42,43,44,45,46,47} ;
        bubbleSort_up(arr);
        System.out.println("最终结果：" + Arrays.toString(arr));

结果：

待排序数组：[12, 4, 54, 57, 87, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47]
#第1次排序结果：[4, 12, 54, 57, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47, 87]
#第2次排序结果：[4, 12, 54, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47, 57, 87]
#第3次排序结果：[4, 12, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第4次排序结果：[4, 3, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第5次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第6次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#bubbleSort_up forloop count - 69
最终结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]

再来看未优化的冒泡排序：

执行：

        int[] arr = new int[]{12,4,54,57,87,3,39,40,41,42,43,44,45,46,47} ;
        bubbleSort(arr);
        System.out.println("最终结果：" + Arrays.toString(arr));

结果：

待排序数组：[12, 4, 54, 57, 87, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47]
#第1次排序结果：[4, 12, 54, 57, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47, 87]
#第2次排序结果：[4, 12, 54, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47, 57, 87]
#第3次排序结果：[4, 12, 3, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第4次排序结果：[4, 3, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第5次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第6次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第7次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第8次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第9次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第10次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第11次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第12次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第13次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#第14次排序结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]
#bubbleSort forloop count - 105
最终结果：[3, 4, 12, 39, 40, 41, 42, 43, 44, 45, 46, 47, 54, 57, 87]

未优化情况下，多排序了36次。

优化后的冒泡排序方法仍然会有一轮无效排序，如果有更好的思路，欢迎留言指正。

优化版的冒泡排序，数组越长、越有序，效率越高。

以上。

内容总结

以上是互联网集市为您收集整理的冒泡排序算法分析 - JAVA版全部内容，希望文章能够帮你解决冒泡排序算法分析 - JAVA版所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/840779.html

来源：【匿名】

【上一篇】TCP的乱序和丢包判断附Reordering更新算法 -实例case 【下一篇】浅谈php实现映射的两种方法（链表和二叉树）

更多 ►

【冒泡排序算法分析 - JAVA版】教程文章相关的互联网学习教程文章

常见算法之排序一【冒泡排序】

冒泡排序是我们编程刚入门基本都会接触的一个排序算法，以来它比较简洁，也比较形象。它的思想就是，让每一个相邻的元素进行比较，假如他们不是按照升序或降序，则交换他们位置，重复这个操作，最大或最小的元素就像泡泡一样，升到了最上面，对剩下的元素重复这个操作，所有的元素就可以排好序了。它的运作方式：1.从头向后比较，假如相邻的元素之间的大小不是按升序或降序则将他们进行比较，若不是指定规则，则交换他们的位置2.按...

算法之冒泡排序【代码】

申明：参考 http://www.cnblogs.com/iuices/archive/2011/11/13/2247193.html原理：将一组数储存在数组List[n]中。逆序，依次比较相邻两个元素的大小，遵循“小数在前，大数在后”的规则交换两数。第一次扫描，将最小的数放在数组的第一位置，第二次扫描只要对除去第一位置的其余的数重复上述步骤即可……共扫描n-1次程序中引入一个布尔量exchange，在每趟排序开始前，先将其置为FALSE。若排序过程中发生了交换...

算法之冒泡排序法【代码】

不会算法的php程序员不是好程序员~ 冒泡排序法：有n个数，第一次排序将最小的（或者最大的）排到最右边，通过由最左开始到最右边的数两两比较。同理，第二次将n-1个数的最小的（或者最大的）排到倒数第二个位置。以此类推。关键点：相邻两个数的两两比较时间复杂度：O（n^2）上代码：　　$a = array(3,8,1,5,7,2,6,4);for($j = count($a) ; $j > 1 ; $j--){for($i = 0 ; $i < $j-1 ; $i++){if($a[$i] > $a[$i+1]){$t = $a[$i];$a[...

C语言中的排序算法--冒泡排序，选择排序，希尔排序【代码】

冒泡排序（Bubble Sort，台湾译为：泡沫排序或气泡排序）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端维基百科：点击打开链接 [cpp] view plain copy /* 用选择法对10个数进行排序 */ #include<stdio.h> void ma...

python基础算法之冒泡排序【代码】

冒泡排序顾名思义，冒泡排序直观的意思是气泡越大冒的越快：），对应到我们的列表中就是数字最大的先选出来，然后依次进行。例如 myList = [1,4,5,0,6],比较方式为：　　相邻的两个数字先进行比较，也就是myList[0]和myList[1]，发现不是">"的关系，就继续比较myList[1]和myList[2]。。。依次进行，发现myList[2]>myList[3](及5>0)，就进行交换，所以走完第一次全列表比较得到新列表[1,4,0,5,6],然后每一次扫描得到的新列表如下：　...

八大排序算法之五--交换排序—冒泡排序（Bubble Sort）【代码】【图】

基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。算法实现：（HDU 1040 亲测 AC）#include<iostream> usingnamespace std; constint N =1005; void BubbleSort(int a[],int ); void print(int a[],int num); void swap(int &a,int &b);int main() {int s[N]...

排序算法之冒泡排序(Bubble Sort)【代码】

基本思想　　假如按照从小到大的顺序排序，对待排序数组进行遍历，如果当前值大于其后一个值则进行交换，不断的进行遍历，直到没有交换动作的发生。冒泡排序的最好时间复杂度为O（n），最坏的时间复杂度为O（n2），所以冒泡排序的平均时间复杂度为O（n2），另外冒泡排序不会改变相同元素的前后顺序，故其是一种稳定的排序算法。实现代码#include<iostream> usingnamespace std;int main() {int MyData[10] = { 7,3,12,46,32,64,13,...

【C语言】两种方式实现冒泡排序算法【代码】

题目要求编写一个C语言程序,实现基本的冒泡排序算法.算法冒泡排序,用一句话来总结:一组数中,相邻的两个数进行比较、交换,将最大(小)数交换至尾(首)部,即完成了一次冒泡排序要想对N个数字进行排序,循环N次即可.如果真的不理解冒泡排序算法,请点击:冒泡排序_360百科核心代码//方式一:从头向尾遍历,将最大数(相对)沉入尾部(相对) void BubbleSort1(int *arr,int sz){int i = 0;int j = 0;assert(arr);for(i=0;i<sz-1;i++){for(j=0;j<s...

冒泡排序算法【代码】

冒泡排序算法的时间复杂度是什么？时间复杂度是O(n^2)。 1 #include "stdafx.h" 2 #include <iostream>3usingnamespace std;4void Swap(int &a, int &b)5{6int temp = a;7 a = b;8 b = temp;9} 1011void Bubble1(int *array, int length) 12{ 13for (int i=length-1;i>0;--i) //首先是要比较多少趟，每一趟冒泡可以确定一个值。最后一趟只剩一个就不用比较了（所以是i>0而不是i>=0)。14 { 15for (int j=0;j<i;++j) 16 ...

【算法】冒泡排序法

/// <summary> /// 冒泡法排序 /// </summary> /// <param name="shuzu"></param> private static void MySort(int[] shuzu) { //比较多少轮 for (int i = 0; i < shuzu.Length - 1; i++) { //每一轮比较多少次 for(int j=shuzu.Length-1;j>i;j--) { if(shuzu[j]>shuzu[j-1]) ...

详解冒泡排序算法【代码】【图】

基本思想冒泡排序的基本思想是：通过对待排序的序列从前向后依次比较相邻元素的值，如果发现逆序则交换。逆序的含义：如果想把序列从小到大排序，那么两个数中前面的比后面的大就是逆序。若需求是将序列从小到大排序，那么每一趟比较都会把值较大的逐渐从前面移动到后面。就像水底的泡泡一样：（如下图，图片来源于网络）例子给定一个数组如下: [ 5 , 8 , -2 , 20 -6 ] 定义两个变量 i 和 j，初始状态 i 存第一个元素的索引，...

数据结构与算法--冒泡排序【代码】

冒泡排序(Bubble Sort)冒泡排序是一种交换排序基本思想：两两比较相邻的的元素，如果反须则交换，直到没有反序的记录为止代码实现： import java.text.SimpleDateFormat;import java.util.Arrays;import java.util.Date;public class BubbleSort {public static void main(String[] args) {int arr[] = {3,9,-1,10,-2};System.out.println("排序前：");System.out.println(Arrays.toString(arr));bubbleSort(arr);System.out.prin...

【Python之路22】冒泡排序算法【代码】

1、变量互换a = 123 b = 456temp = a a = b b = temp python比较简单的变量互换：a = 123 b = 456 a,b = b,a print(a,b) 2、将列表中最大的值放置到最后#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,44,33,66,22] for i in range(len(li)-1):if li[i] > li[i+1]:temp = li[i]li[i] = li[i+1]li[i+1] = tempprint(li) 3、循环嵌套冒泡排序法#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,44,33,66,77,99,44] fo...

冒泡排序C++算法【代码】

冒泡排序算法C++#include <iostream> using namespace std; template<typename T> //整数或浮点数皆可使用 void bubble_sort(T arr[], int len) {int i, j; T temp;for (i = 0; i < len - 1; i++)for (j = 0; j < len - 1 - i; j++)if (arr[j] > arr[j + 1]){temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;} } int main() {int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };int len = (int) sizeof(arr) / siz...

屌丝需要逆袭之学习C++和算法------冒泡排序【代码】

1 #include <iostream>2usingnamespace std;3int BubbleSort(int A[],int n);4int OutPut(int A[],int n);5int main()6{7int A[]={5,1,3,2,4};8 BubbleSort(A,5);9 OutPut(A,5); 10return0; 11} 1213int BubbleSort(int A[],int n) 14{ 15for(int i=0;i<n-1;i++) 16 { 17for(int j=i+1;j<n;j++) 18 { 19if(A[i]>A[j]) 20 { 21int temp=A[i]; 22 A[i]=A[j]; 23 A[j]=...

首页 / 算法 / 冒泡排序算法分析 - JAVA版

冒泡排序算法分析 - JAVA版

内容导读

内容图文

内容总结

内容备注

内容手机端

【冒泡排序算法分析 - JAVA版】教程文章相关的互联网学习教程文章

常见算法之排序一【冒泡排序】

算法之冒泡排序【代码】

算法之冒泡排序法【代码】

C语言中的排序算法--冒泡排序，选择排序，希尔排序【代码】

python基础算法之冒泡排序【代码】

八大排序算法之五--交换排序—冒泡排序（Bubble Sort）【代码】【图】

排序算法之冒泡排序(Bubble Sort)【代码】

【C语言】两种方式实现冒泡排序算法【代码】

冒泡排序算法【代码】

【算法】冒泡排序法

详解冒泡排序算法【代码】【图】

数据结构与算法--冒泡排序【代码】

【Python之路22】冒泡排序算法【代码】

冒泡排序C++算法【代码】

屌丝需要逆袭之学习C++和算法------冒泡排序【代码】

JAVA - 相关标签

冒泡排序 - 相关标签

算法分析 - 相关标签

算法 - 最新教程

算法 - 最热教程