java实现排序算法之冒泡排序法详细讲解

最新推荐文章于 2024-06-07 09:15:00 发布
最新推荐文章于 2024-06-07 09:15:00 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 排序算法 文章标签： java 排序算法 冒泡排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MonkeyBrothers/article/details/78886251
版权
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序。
这里的介绍有简单到复杂（其实不是复杂了，只是进行了简化和规范而已，其实原理基本相同的）。
首先我们来看下面的程序（我在每行程序上都进行了注释，以便于理解。）： 
package com.hry.bubble_sort;

import java.util.Arrays;

/**
 * @author 侯瑞阳
 * java实现冒泡排序算法
 */
public class BubbleSort {

    /**
     * 定义一个静态的方法方便在主函数中调用
     */
    public static void FirstSort(int arr[]) {
        // 初始化i为0 因为是数组arr[]是从arr[0]开始的。
        int i = 0;
        // 输出一句库进行提示
        System.out.print("第一趟，第一次排序");
        // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
        if (arr[i] < arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        // 输出排序号之后的结果
        System.out.println(Arrays.toString(arr));

    }

    // 主函数
    public static void main(String [] args) {
        // 初始化一个数组
        int arr[] = {1, 2, 3, 4, 5};
        // 调用定义好的静态方法进行排序
        FirstSort(arr);
    }
}
运行程序输出的结果是： 
第一趟，第一次排序[2, 1, 3, 4, 5]
这样以来，我们是不是就进行了一次简单的比较了呢？那么，1 和 3在进行比较之后，是不是1 和 3 交换位置，输出 [2， 3， 1， 4， 5 ] 呢？怎么用程序来实现呢？
如果还不明白的话。我给你一个初始数组是 [ 2, 1, 3, 4, 5 ] 让你来用程序改成[ 2， 3， 1， 4， 5 ] 呢？原来就是上面程序在重复一边呀，那赶紧用 代码来实现下吧！ 
package com.hry.bubble_sort;

import java.util.Arrays;

/**
 * @author 侯瑞阳
 * java实现冒泡排序算法
 */
public class BubbleSort {

    /**
     * 定义一个静态的方法方便在主函数中调用
     */
    public static void FirstSort(int arr[]) {
        // 初始化i为0 因为是数组arr[]是从arr[0]开始的。
        int i = 0;
        // 输出一句库进行提示
        System.out.print("第一趟，第一次排序");
        // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
        if (arr[i] < arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        // 输出排序号之后的结果
        System.out.println(Arrays.toString(arr));
        i++;

        System.out.print("第一趟，第二次排序");
        // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
        if (arr[i] < arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        // 输出排序号之后的结果
        System.out.println(Arrays.toString(arr));
        i++;

        System.out.print("第一趟，第三次排序");
        // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
        if (arr[i] < arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        // 输出排序号之后的结果
        System.out.println(Arrays.toString(arr));
        i++;

        System.out.print("第一趟，第四次排序");
        // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
        if (arr[i] < arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
        // 输出排序号之后的结果
        System.out.println(Arrays.toString(arr));
        i++;
    }

    // 主函数
    public static void main(String [] args) {
        // 初始化一个数组
        int arr[] = {1, 2, 3, 4, 5};
        // 调用定义好的静态方法进行排序
        FirstSort(arr);
    }
}
我想有一小部分人估计忘记了在刚开始定义的 i 的变量。可不要忘记在每次执行完毕之后 不要忘记把 i自身加上1 参与下一次运算呀！来看运行结果： 

第一趟，第 1 次排序[2, 1, 3, 4, 5]
第一趟，第 2 次排序[2, 3, 1, 4, 5]
第一趟，第 3 次排序[2, 3, 4, 1, 5]
第一趟，第 4 次排序[2, 3, 4, 5, 1]


好了，通过上面的代码我们简单找出了最小值 并放在了数组最后一个位置。那大家有没有发现其实是有很多代码是重复的呢？聪明的人已经想到了解决办法。既然重复，那么我定义一个循环不就解决了吗。下面来看实现代码：
 
package com.hry.bubble_sort;

import java.util.Arrays;

/**
 * @author 侯瑞阳
 * java实现冒泡排序算法
 */
public class BubbleSort {

    /**
     * 定义一个静态的方法方便在主函数中调用
     */
    public static void FirstSort(int arr[]) {
        // 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数
        int length = arr.length - 1;
        for (int i = 0; i < length; i++) {
            // 输出一句库进行提示
            System.out.print("第一趟，第一次排序");
            // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
            if (arr[i] < arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            // 输出排序号之后的结果
            System.out.println(Arrays.toString(arr));
        }
    }

    // 主函数
    public static void main(String [] args) {
        // 初始化一个数组
        int arr[] = {1, 2, 3, 4, 5};
        // 调用定义好的静态方法进行排序
        FirstSort(arr);
    }
}
运行结果： 

第一趟，第 1 次排序[2, 1, 3, 4, 5]
第一趟，第 2 次排序[2, 3, 1, 4, 5]
第一趟，第 3 次排序[2, 3, 4, 1, 5]
第一趟，第 4 次排序[2, 3, 4, 5, 1]

有没有发现和之前的一样呢？但是代码是不是减少了很多呢？那么是不是第二趟第三趟第四趟也可以按照这个来实现呢？下面来看实现代码： 
package com.hry.bubble_sort;

import java.util.Arrays;

/**
 * @author 侯瑞阳
 * java实现冒泡排序算法
 */
public class BubbleSort {

    /**
     * 定义一个静态的方法方便在主函数中调用
     */
    public static void FirstSort(int arr[]) {
        // 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数
        int length = arr.length - 1;
        for (int i = 0; i < length; i++) {
            // 输出一句库进行提示
            System.out.print("第一趟，第 "+ ( i + 1 ) +" 次排序");
            // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
            if (arr[i] < arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            // 输出排序号之后的结果
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("==============分割线==============");

        for (int i = 0; i < length; i++) {
            // 输出一句库进行提示
            System.out.print("第二趟，第 "+ ( i + 1 ) +" 次排序");
            // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
            if (arr[i] < arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            // 输出排序号之后的结果
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("==============分割线==============");

        for (int i = 0; i < length; i++) {
            // 输出一句库进行提示
            System.out.print("第三趟，第 "+ ( i + 1 ) +" 次排序");
            // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
            if (arr[i] < arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            // 输出排序号之后的结果
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("==============分割线==============");

        for (int i = 0; i < length; i++) {
            // 输出一句库进行提示
            System.out.print("第四趟，第 "+ ( i + 1 ) +" 次排序");
            // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
            if (arr[i] < arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
            // 输出排序号之后的结果
            System.out.println(Arrays.toString(arr));
        }
    }

    // 主函数
    public static void main(String [] args) {
        // 初始化一个数组
        int arr[] = {1, 2, 3, 4, 5};
        // 调用定义好的静态方法进行排序
        FirstSort(arr);
    }
}

来看运行结果： 
第一趟，第 1 次排序[2, 1, 3, 4, 5]
第一趟，第 2 次排序[2, 3, 1, 4, 5]
第一趟，第 3 次排序[2, 3, 4, 1, 5]
第一趟，第 4 次排序[2, 3, 4, 5, 1]
==============分割线==============
第二趟，第 1 次排序[3, 2, 4, 5, 1]
第二趟，第 2 次排序[3, 4, 2, 5, 1]
第二趟，第 3 次排序[3, 4, 5, 2, 1]
第二趟，第 4 次排序[3, 4, 5, 2, 1]
==============分割线==============
第三趟，第 1 次排序[4, 3, 5, 2, 1]
第三趟，第 2 次排序[4, 5, 3, 2, 1]
第三趟，第 3 次排序[4, 5, 3, 2, 1]
第三趟，第 4 次排序[4, 5, 3, 2, 1]
==============分割线==============
第四趟，第 1 次排序[5, 4, 3, 2, 1]
第四趟，第 2 次排序[5, 4, 3, 2, 1]
第四趟，第 3 次排序[5, 4, 3, 2, 1]
第四趟，第 4 次排序[5, 4, 3, 2, 1]

经过四次排序最终一个简单的冒泡排序就完成了。那么细心的同学已经发现了，还是重复了了三次，是不是也可以用循环呢？当然是可以的，下面看代码： 
package com.hry.bubble_sort;

import java.util.Arrays;

/**
 * @author 侯瑞阳
 * java实现冒泡排序算法
 */
public class BubbleSort {

    /**
     * 定义一个静态的方法方便在主函数中调用
     */
    public static void FirstSort(int arr[]) {
        int length = arr.length - 1;
        for(int j = 0; j < length; j++) {
            // 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数
            for (int i = 0; i < length; i++) {
                // 输出一句库进行提示
                System.out.print("第" + (j + 1 ) + "趟，第 "+ ( i + 1 ) +" 次排序");
                // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
                if (arr[i] < arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
                // 输出排序号之后的结果
                System.out.println(Arrays.toString(arr));
            }
            System.out.println("==============分割线==============");
        }

    }

    // 主函数
    public static void main(String [] args) {
        // 初始化一个数组
        int arr[] = {1, 2, 3, 4, 5};
        // 调用定义好的静态方法进行排序
        FirstSort(arr);
    }
}



实现结果： 
第1趟，第 1 次排序[2, 1, 3, 4, 5]
第1趟，第 2 次排序[2, 3, 1, 4, 5]
第1趟，第 3 次排序[2, 3, 4, 1, 5]
第1趟，第 4 次排序[2, 3, 4, 5, 1]
==============分割线==============
第2趟，第 1 次排序[3, 2, 4, 5, 1]
第2趟，第 2 次排序[3, 4, 2, 5, 1]
第2趟，第 3 次排序[3, 4, 5, 2, 1]
第2趟，第 4 次排序[3, 4, 5, 2, 1]
==============分割线==============
第3趟，第 1 次排序[4, 3, 5, 2, 1]
第3趟，第 2 次排序[4, 5, 3, 2, 1]
第3趟，第 3 次排序[4, 5, 3, 2, 1]
第3趟，第 4 次排序[4, 5, 3, 2, 1]
==============分割线==============
第4趟，第 1 次排序[5, 4, 3, 2, 1]
第4趟，第 2 次排序[5, 4, 3, 2, 1]
第4趟，第 3 次排序[5, 4, 3, 2, 1]
第4趟，第 4 次排序[5, 4, 3, 2, 1]
==============分割线==============
到此就结束了吗？显然更加细心爱钻研的小伙伴就会发现在“第四趟的第一次排序” 之后结果就已经出来了，后面的不就重复了吗？我为发现这个问题的小伙伴点个赞。那么就会有下面的第二个版本，代码如下： 
package com.hry.bubble_sort;

import java.util.Arrays;

/**
 * @author 侯瑞阳
 * java实现冒泡排序算法
 */
public class BubbleSort {

    /**
     * 定义一个静态的方法方便在主函数中调用
     */
    public static void FirstSort(int arr[]) {
        int length = arr.length - 1;
        for(int j = 0; j < length; j++) {
            // 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数
            // 由于之前的代码存在问题，其解决办法就是在比较次数上做手脚。
            for (int i = 0; i < arr.length - 1 - j; i++) {
                // 输出一句库进行提示
                System.out.print("第" + (j + 1 ) + "趟，第 "+ ( i + 1 ) +" 次排序");
                // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
                if (arr[i] < arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
                // 输出排序号之后的结果
                System.out.println(Arrays.toString(arr));
            }
            System.out.println("==============分割线==============");
        }

    }

    // 主函数
    public static void main(String [] args) {
        // 初始化一个数组
        int arr[] = {1, 2, 3, 4, 5};
        // 调用定义好的静态方法进行排序
        FirstSort(arr);
    }
}

运行结果： 
第1趟，第 1 次排序[2, 1, 3, 4, 5]
第1趟，第 2 次排序[2, 3, 1, 4, 5]
第1趟，第 3 次排序[2, 3, 4, 1, 5]
第1趟，第 4 次排序[2, 3, 4, 5, 1]
==============分割线==============
第2趟，第 1 次排序[3, 2, 4, 5, 1]
第2趟，第 2 次排序[3, 4, 2, 5, 1]
第2趟，第 3 次排序[3, 4, 5, 2, 1]
==============分割线==============
第3趟，第 1 次排序[4, 3, 5, 2, 1]
第3趟，第 2 次排序[4, 5, 3, 2, 1]
==============分割线==============
第4趟，第 1 次排序[5, 4, 3, 2, 1]
==============分割线==============

这样是不是也能够得出结果，而且比较简单呢？那么这样就结束了吗？显然不是，如果我们排序一次之后就已经得到了我们想要的顺序那么后面的是不是就不用进行了呢？我们来看下面程序帮助我们更好理解： 

package com.hry.bubble_sort;

import java.util.Arrays;

/**
 * @author 侯瑞阳
 * java实现冒泡排序算法
 */
public class BubbleSort {

    /**
     * 定义一个静态的方法方便在主函数中调用
     */
    public static void FirstSort(int arr[]) {
        int length = arr.length - 1;
        for (int j = 0; j < length; j++) {
            // 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数
            // 由于之前的代码存在问题，其解决办法就是在比较次数上做手脚。
            for (int i = 0; i < arr.length - 1 - j; i++) {
                // 输出一句库进行提示
                System.out.print("第" + (j + 1) + "趟，第 " + (i + 1) + " 次排序");
                // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
                if (arr[i] < arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
                // 输出排序号之后的结果
                System.out.println(Arrays.toString(arr));
            }
        }
    }


    public static void FinalSort(int arr[]) {
        int length = arr.length - 1;
        boolean bool = true;
        for (int j = 0; j < length; j++) {
            // 因为通过之前发现五个数重复执行了四次，所以定义一个整形来控制for循环的次数
            // 由于之前的代码存在问题，其解决办法就是在比较次数上做手脚。
            for (int i = 0; i < arr.length - 1 - j; i++) {
                // 输出一句库进行提示
                System.out.print("第" + (j + 1) + "趟，第 " + (i + 1) + " 次排序");
                // 循环判断找出最大值，就算不学冒泡排序，我们在学习比较大小的时候也应该会了
                if (arr[i] < arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    bool = false;
                }
                // 输出排序号之后的结果
                System.out.println(Arrays.toString(arr));
            }
            if (bool) {
                break;
            }
        }
    }
    
    // 主函数
    public static void main(String [] args) {
        int arr[] = {7, 4, 2, 1};
        FirstSort(arr);
        System.out.println("==============分割线==============");
        arr = new int[]{7, 4, 2, 1};
        FinalSort(arr);
    }
}


运行结果： 

第1趟，第 1 次排序[7, 4, 2, 1]
第1趟，第 2 次排序[7, 4, 2, 1]
第1趟，第 3 次排序[7, 4, 2, 1]
第2趟，第 1 次排序[7, 4, 2, 1]
第2趟，第 2 次排序[7, 4, 2, 1]
第3趟，第 1 次排序[7, 4, 2, 1]
==============分割线==============
第1趟，第 1 次排序[7, 4, 2, 1]
第1趟，第 2 次排序[7, 4, 2, 1]
第1趟，第 3 次排序[7, 4, 2, 1]

虽然最后也进行了三趟但是第二种方法显然比第一种还要简单。


小猴子的技术笔记
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现冒泡排序
欢迎来到多多的游乐园！
02-17 3848
冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序的时间复杂度是On2，所以它并不适合对大数据集进行排序。
Java排序算法之冒泡排序
Science Explorer
07-19 508
Java排序算法之冒泡排序交换类排序主要是通过两两比较待排元素的关键字，若发现与排序要求相逆，则“交换” 之。冒泡排序是交换类排序的一种。本篇文章讲解以下内容： 基本思想 源码 源码解析 算法原理 效率分析
用java语言实现冒泡排序
weixin_42594427的博客
02-15 83
以下是Java语言实现冒泡排序的示例代码： public class BubbleSort { public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j &l...
冒泡排序详解（附有Java详细代码）
最新发布
Weirdo的博客
06-07 1794
冒泡排序是一种简单直观的排序算法，它通过相邻元素之间的比较和交换来实现排序。虽然它在效率上不如其他排序算法，但在某些特定场景下仍然有其应用价值。在实际应用中，我们应该根据具体需求和数据特点选择合适的排序算法。同时，我们也可以通过一些优化策略来提高冒泡排序的效率，如标记交换和鸡尾酒排序等。
起泡法java_java语言实现冒泡排序
weixin_31458015的博客
12-28 157
本文主要向大家介绍了java语言实现冒泡排序，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。冒泡排序冒泡排序的效率很低，但是算法实现起来很简单，因此很适合作为研究排序的入门算法。基本思想对当前还未排好序的范围内的全部数，自上而下对相邻的俩个数依次进行比较和调整，让较大的数下沉，较小的数往上冒。即：每当俩相邻的数比较后发现他们的排序与排序的要求相反时，就将他们交换。每次遍历都可确定一...
Java 与排序算法（1）：冒泡排序
暗星涌动
05-21 1万+
冒泡排序（Bubble Sort）是一种简单的排序算法，它的基本思想是通过不断交换相邻两个元素的位置，使得较大的元素逐渐往后移动，直到最后一个元素为止。冒泡排序的时间复杂度为On2，空间复杂度为O1，是一种稳定的排序算法。
【Java】冒泡排序
zcxyywd的博客
06-12 8758
冒泡排序详解。
java 排序算法实现 其一：冒泡排序
Maxwell_7
10-17 663
冒泡排序法的java和C++实现
java基础 经典算法之冒泡排序详解
07-11
1.冒泡排序的原理:每次都从第一个元素开始(索引0),向后两两比较,只要后面的比前面的大,就交换(从大到小) 2.通过画图分析,5个数字排4趟,n数字排n-1趟,而外层的for循环代表的是循环的趟数,所以外层循环的结束条件是...
Java冒泡排序算法实现
03-20
以下是关于Java冒泡排序的详细解释和实现。 冒泡排序的基本思想是通过重复遍历待排序的序列，依次比较相邻元素，如果顺序错误就交换它们的位置。这一过程就像水底下的气泡一样，小的元素逐渐“浮”到序列的顶端。...
java常见排序算法合集讲解以及java实现.zip
11-29
Java中常见的排序算法 1.直接插入排序 2.希尔排序 3.选择排序 4.冒泡排序 5.归并排序 6.快速排序 7.堆排序 8.计数排序 9.桶排序 10.基数排序 包含这十种算法的讲解以及动态图解（ppt）和java实现
排序算法的Java实现
07-19
以下将详细解释标题和描述中涉及的几种排序算法的Java实现。 1. **计数排序(RadixSort.java)** 计数排序是一种非基于比较的排序算法，适用于整数排序。它通过计算每个数字出现的次数，然后按照数字的位数从低位到...
Java实现几种常见排序算法代码
09-05
【Java实现几种常见排序算法代码】的描述中提到了排序的重要性以及分类，下面将详细讲解这些排序算法。 1. **排序算法的意义与稳定度** - 排序是计算机科学中的基本操作，它使得数据组织有序，便于查找、分析和...
java冒泡排序
papillonlong的博客
01-31 1万+
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，我们将五个无序的数：3, 9, -1, 10, -2 使用冒泡排序法将其排成一个从小。因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在。(3) 如果我们发现在某趟排序中，没有发生一次交换， 可以提前结束冒泡排序。若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。(2)每一趟排序的次数在逐渐的减少。
java 冒泡排序
weixin_45428254的博客
06-06 5995
这段代码实现了一个简单的冒泡排序算法，它接受一个整数数组作为参数。在函数内部，我们使用两个嵌套的循环来遍历数组并比较相邻的元素。如果它们顺序不正确，我们就交换它们的位置。最终，数组中的元素将按升序排列。Java 冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来，直到没有再需要交换的元素。
冒泡排序（Java）（完整代码）
热门推荐
weixin_48544279的博客
07-15 10万+
你好，我是 hello，word。一个程序小白。
Java—排序算法（冒泡排序）
weixin_57684937的博客
02-13 2981
冒泡排序简介
Java代码实现—冒泡排序
weixin_44580000的博客
05-09 7万+
目录 1、前言 2、冒泡排序 2.1 算法思路 2.2 代码实现过程： 3、代码优化 3.1趟数优化 3.2 循环次数优化 3.3 排序完成优化 4、结语 1、前言 我们书接上回，接着数组中的遗留问题来讲解这节的冒泡排序，干货满满，里面还涉及到代码的优化，希望大家有所收获 2、冒泡排序 冒泡排序思想：给定一个数组，让数组升序 (降序) 排序。 2.1 算法思路 假设排升序： 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数.
Java实现排序算法全解析：从基础到进阶
"排序算法复习大全(Java实现).doc 是一篇关于Java实现各种排序算法的文档，涵盖了插入排序、冒泡排序、选择排序、Shell排序和快速排序等基础排序算法。文档强调了学习和掌握算法对于提升编程技能的重要性，特别对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值