Java排序算法中的冒泡排序算法实现_开发_开发者

Java冒泡排序算法

1、冒泡排序原理

冒泡排序只会操作相邻的两个数据。

每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。

如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排编程序工作。

如果我们要对一组数据 4，5，6，3，2，1从小到到大进行排序，第一次冒泡操作的详细过程就是这样：

4和5比较，4小于5，不进行位置交换，结果：[4，5，6，3，2，1]
5和6比较，5小于6，不进行位置交换，结果：[4，5，6，3，2，1]
6和3比较，6大于3，进行位置交换，结果：[4，5，3，6，2，1]
6和2比较，6大于2，进行位置交换，结果：[4，5，3，2，6，1]
6和1比较，6大于1，进行位置交换，结果：[4，5，3，2，1，6]

要想完成所有数据的排序，只要进行 6 次这样的冒泡操作就可以了：

冒泡次数	冒泡后的结果
初始状态	[ 4 ，5，6，3, 2, 1]
第一次冒泡	[ 4 ，5，3，2, 1, 6]
第二次冒泡	[ 4 ，3，1，1, 5, 6]
第三次冒泡	[ 3 ，2，1，4, 5, 6]
第四次冒泡	[ 2 ，1，3，4, 5, 6]
第五次冒泡	[ 1，2，3，4, 5, 6]
第六次冒泡android	[ 1，2，3，4, 5, 6]

2、代码实现

 *  从小到大排序
     * @param a
     * @return
     */
    public static int[] bubbleSort(int[] a){
        if (a.length<=1)
            return a;
        //外层for总共冒泡操作的次数
        for (int i=0;i<a.length-1;i++){
            //内层for  两个元素的交换
            for (int j=0;j<a.length-i-1;j++){
                if (a[j]>a[j+1]){
                    //交换数据
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                }
            }
        }
        return a;
    }

3、冒泡排序优化

通过上图，我们发现在第五次冒泡操作后，已经没有数据交换，这时已经达到完全有序，不用再继续执行后续的冒泡操作，我们可以通过添加一个标识符，来判断当前是否还有数据交换

经过优化，对 4，5，6，3，2，1这组数据排序，只需执行5次冒泡操作。

冒泡次数	冒泡后的结果	是否有数据交换初始php状态
初始状态	[ 4 ，5，6，3, 2, 1]	----
第一次冒泡	[ 4 ，5，3，2, 1, 6]	有
第二次冒泡	[ 4 ，3，1，1, 5, 6]	有
第三次冒泡	[ 3 ，2，1，4, 5, 6]	有
第四次冒泡	[ 2 ，1，3，编程4, 5, 6]	有
第五次冒泡	[ 1，2，3，4, 5, 6]	无

代码实现：

/**
     *  从小到大排序
     * @param a
     * @return
     */
    public static int[] bubbleSort(int[] a){
        if (a.length<=1)
            return a;
        //外层for总共冒泡操作的次数
        for (int i=0;i<a.length-1;i++){
            //标识当前冒泡操作是否有数据交换
            boolean flag=false;
            //内层for  两个元素的交换
            for (injavascriptt j=0;j<a.length-i-1;j++){
                if (a[j]>a[j+1]){
                    //交换数据
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    flag=true;
                }
            }
            //如果数据已经有序，无需再执行冒泡操作
            if (!flag) break;
        }
        return a;
    }