冒泡排序及其改进算法

最新推荐文章于 2023-10-27 23:20:16 发布

原创最新推荐文章于 2023-10-27 23:20:16 发布 · 847 阅读

2 ·

CC 4.0 BY-SA版权

本文介绍了冒泡排序的基本思想和效率问题，然后详细讲解了改进的冒泡排序算法，该算法通过在每次循环中局部调整数据顺序，提高了排序效率。通过代码示例展示了两种冒泡排序的运行结果，对比显示改进算法的优势。

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

1、简单冒泡排序的思想就是像冒水泡一样，将最大的泡冒在数组最后，但是这里面有一个很大的问题：每次循环只是找最大的数，而其他数则原封不动，即数据的流动很慢，这样的话，效率自然会很低，因为排一次序，只做一件事：找最大的数，并把这个数复制到未排数组的最前面。
2、改进的冒泡排序呢，就是在原来简单冒泡排序的基础上，不再是只找最大的数，而是遇到比当前数据大的数，就放在当前的数后面，这样一次排序下来，即把较小的数局部前移，也让大的数据局部往数组的末尾走，这样的话，效率会有很大提升。
下面是代码块：

简单冒泡排序代码块：
public class BubbleSort {

    public static void main(String[] args) {
        int[] s={4,1,3,2,9,7,5,6,8};
        System.out.println("排序前的数组： ");
        for(int i=0;i<s.length;i++){
            System.out.print(s[i]+" ");
        }
        System.out.println();
        System.out.println("排序过程：");
        Bubble1(s); //Bubble1（）是简单冒泡排序
        //Bubble2(s);  //Bubble2()是改进的冒泡排序
        System.out.println("排序后的数组： ");
        for(int i=0;i<s.length;i++){
            System.out.print(s[i]+" ");
        }

    }
    //改进的冒泡排序，在原来冒泡排序的基础上，在第二层循环开始从后向前进行简单比较，实现局部有序，并且
    //增加一个标识符flag用于判定是否需要继续排序，预防不必要的排序过程。
  private static void Bubble2(int[] s) {
        boolean flag=true;
        for(int i=0;i<s.length&&flag;i++){
            flag=false;
            for(int j=s.length-2;j>=i;j--){
                if(s[j]>s[j+1]){
                    int a=s[j];
                    s[j]=s[j+1];
                    s[j+1]=a;
                    flag=true;
                }
            }
            for(int k=0;k<s.length;k++){
                System.out.print(s[k]+" ");
            }
            System.out.println();
        }

    }
//最简单原始的冒泡排序算法，但是效率也是最低的
    private static void Bubble1(int[] s) {
        for(int i=0;i<s.length;i++){
            for(int j=i+1;j<s.length;j++){
                if(s[i]>s[j]){
                    int a=s[i];
                    s[i]=s[j];
                    s[j]=a;
                }
            }
            for(int k=0;k<s.length;k++){
                System.out.print(s[k]+" ");
            }
            System.out.println();
        }

    }

}

简单冒泡排序的运行结果如下：

排序前的数组： 
4 1 3 2 9 7 5 6 8 
排序过程：
1 4 3 2 9 7 5 6 8 
1 2 4 3 9 7 5 6 8 
1 2 3 4 9 7 5 6 8 
1 2 3 4 9 7 5 6 8 
1 2 3 4 5 9 7 6 8 
1 2 3 4 5 6 9 7 8 
1 2 3 4 5 6 7 9 8 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 8 9 
排序后的数组： 
1 2 3 4 5 6 7 8 9

执行Bubble2(s)的结果如下：

排序前的数组： 
4 1 3 2 9 7 5 6 8 
排序过程：
1 4 2 3 5 9 7 6 8 
1 2 4 3 5 6 9 7 8 
1 2 3 4 5 6 7 9 8 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 7 8 9 
排序后的数组： 
1 2 3 4 5 6 7 8 9

对同一组数据进行排序，改进的算法，效果明显较优！