冒泡算法及其改良（Java版）

最新推荐文章于 2024-08-20 11:44:03 发布

亂室佳人

最新推荐文章于 2024-08-20 11:44:03 发布

阅读量172

点赞数 1

文章标签： java 排序算法数据结构算法

本文链接：https://blog.youkuaiyun.com/weixin_43149006/article/details/104963957

版权

本文详细介绍了冒泡排序的原始版本以及两种改良方法。原始版通过不断交换相邻未排序元素实现排序；改良版在发现数组已有序时提前终止遍历；再次改良版则在遍历过程中跳过已有序的数组片段，提高效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、原始版冒泡算法：暴力美学！！！

import java.util.Arrays;

public class yuanshimaopao {
    public static void sort(int array[]){
        //中间变量，用于暂存数据
        int tmp  = 0;

        for(int i = 0; i < array.length; i++){
            for( int j = 0; j < array.length - i - 1; j++){
                if(array[j] > array[j+1]) {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }

    public static void main(String[] args){
        int[] array = {3,5,1,4,6,2,7,8,9};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}

二、改良版冒泡算法：在后续遍历中可能在全部遍历结束前，数组已经是有序的了，此时，可以跳出遍历了。

import java.util.Arrays;

public class maopaogailiang01 {
    public static void sort(int array[]){
        //中间变量，用于暂存数据
        int tmp  = 0;

        //判断是否本次遍历不存在元素交换情况
        boolean sorted = true;

        for(int i = 0; i < array.length; i++){
            for( int j = 0; j < array.length - i - 1; j++){
                if(array[j] > array[j+1]) {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    //出现了排序情况
                    sorted = true;
                }
            }
            //本轮未出现 排序情况，可以视为数组已有序
            if (!sorted){
                break;
            }
        }
    }

    public static void main(String[] args){
        int[] array = {3,5,1,4,6,2,7,8,9};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}

三、再次改良版冒泡算法：在初始遍历时可能在数组右侧已经存在部分有序的数组片段了，此时，可以跳过多有序片段的遍历。

import java.util.Arrays;

public class maopaogailiang02 {
    public static void sort(int array[]){
        //中间变量，用于暂存数据
        int tmp  = 0;

        //判断是否本次遍历不存在元素交换情况
        boolean sorted = true;

        //保存数组无序部分的边界
        int border = array.length-1;
        //记录最后一次出现交换的下标
        int lastjiaohuan = 0;

        for(int i = 0; i < array.length; i++){
            for( int j = 0; j < border; j++){
                if(array[j] > array[j+1]) {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    //出现了排序情况
                    sorted = true;

                    lastjiaohuan = j;
                }
            }
            //本轮未出现 排序情况，可以视为数组已有序
            if (!sorted){
                break;
            }
            border = lastjiaohuan;
        }
    }

    public static void main(String[] args){
        int[] array = {3,5,1,4,6,2,7,8,9};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}