冒泡排序

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了冒泡排序相关的知识,希望对你有一定的参考价值。

不优化的冒泡排序和普通的排序没有啥差别;优化的冒泡排序对某些排序才有优化作用,很大部分和不优化,普通排序一样;

测试代码(输出比较次数,数据交换次数):

测试类:

package com.it.bubbleSortTest;

import static org.junit.Assert.*;

import org.junit.Test;

import com.it.bubbleSort.BubbleSorting;

public class BubbleSortingTest {
    
    /**
     * 排序到底哪个好
     */
    @Test
    public void testSortingWhichIsGood() {
        //调用普通方法进行排序9 4 5 6 8 3 2 7 10 1  {9,4,5,6,8,3,2,7,10,1}
        int[] intArray={9,4,5,6,8,3,2,7,10,1};
        BubbleSorting.fun(intArray);
        System.out.println();//换行
        //调用普通冒泡方法进行排序
        int[] intArray1={9,4,5,6,8,3,2,7,10,1};
        BubbleSorting.bubbleSort(intArray1);
        System.out.println();
        int[] intArray2={9,4,5,6,8,3,2,7,10,1};
        BubbleSorting.goodBubbleSort(intArray2);
        System.out.println();
    }
    /**
     * 排序到底哪个好
     */
    @Test
    public void testSortingWhichIsGood1() {
        //调用普通方法进行排序9 4 5 6 8 3 2 7 10 1  {9,6,5,4,8,3,2,7,10,1}
        int[] intArray={9,6,5,4,8,3,2,7,10,1};
        BubbleSorting.fun(intArray);
        System.out.println();//换行
        //调用普通冒泡方法进行排序
        int[] intArray1={9,6,5,4,8,3,2,7,10,1};
        BubbleSorting.bubbleSort(intArray1);
        System.out.println();
        int[] intArray2={9,6,5,4,8,3,2,7,10,1};
        BubbleSorting.goodBubbleSort(intArray2);
        System.out.println();
    }
    
    /**
     * 排序到底哪个好
     */
    @Test
    public void testSortingWhichIsGood2() {
        //调用普通方法进行排序9 4 5 6 8 3 2 7 10 1  {10,9,8,7,6,5,4,3,2,1}
        int[] intArray={10,9,8,7,6,5,4,3,2,1};
        BubbleSorting.fun(intArray);
        System.out.println();//换行
        //调用普通冒泡方法进行排序
        int[] intArray1={10,9,8,7,6,5,4,3,2,1};
        BubbleSorting.bubbleSort(intArray1);
        System.out.println();
        int[] intArray2={10,9,8,7,6,5,4,3,2,1};
        BubbleSorting.goodBubbleSort(intArray2);
        System.out.println();
    }
    
    /**
     * 排序到底哪个好
     */
    @Test
    public void testSortingWhichIsGood3() {
        //调用普通方法进行排序9 4 5 6 8 3 2 7 10 1  {10,2,3,4,5,6,7,8,9,1}
        int[] intArray={10,2,3,4,5,6,7,8,9,1};
        BubbleSorting.fun(intArray);
        System.out.println();//换行
        //调用普通冒泡方法进行排序
        int[] intArray1={10,2,3,4,5,6,7,8,9,1};
        BubbleSorting.bubbleSort(intArray1);
        System.out.println();
        int[] intArray2={10,2,3,4,5,6,7,8,9,1};
        BubbleSorting.goodBubbleSort(intArray2);
        System.out.println();
    }
    /**
     * 排序到底哪个好
     */
    @Test
    public void testSortingWhichIsGood5() {
        //调用普通方法进行排序9 4 5 6 8 3 2 7 10 1  {3,2,1,4,5,6,7,8,9,10}
        int[] intArray={3,2,1,4,5,6,7,8,9,10};
        BubbleSorting.fun(intArray);
        System.out.println();//换行
        //调用普通冒泡方法进行排序
        int[] intArray1={3,2,1,4,5,6,7,8,9,10};
        BubbleSorting.bubbleSort(intArray1);
        System.out.println();
        int[] intArray2={3,2,1,4,5,6,7,8,9,10};
        BubbleSorting.goodBubbleSort(intArray2);
        System.out.println();
    }
}

 

 排序方法类:

package com.it.bubbleSort;
/**
 * 1.按普通方法实现
 * @author Peter
 *
 */
public class BubbleSorting {
    
    static int t;

    /**
     * 1.普通的方法数组小到大排序
     * 1)首先第0位和其他位比较,每次比较后,把小的放在第0位;然后把第1位和后面1+n位比较,把小的放在第1位;
     * 按前面方法,直到n-2位和最后一位进行比较;
     * 2)时间复杂度为O(n*n)
     * 3)这种算法缺点:1.时间复杂度很难最小化;2.每次循环把小的后放后面了,添加记录移动次数
     * 看下面2的最终位置变化
    开始:9 4 5 6 8 3 2 7 10 1  (下标从左到右分别是0~9)按照上面的程序进行对比交换
    第一次:4 9 5 6 8 3 2 7 10 1 
    第二次:4 9 5 6 8 3 2 7 10 1 
    。。。:(没有交换)
    第五次:3 9 5 6 8 4 2 7 10 1 
    第六次:2 9 5 6 8 3 4 7 10 1 
    。。。:(没有交换)
    第十次:1 9 5 6 8 3 4 7 10 2 
    可以看出,原来较小的数是在前面的,经过一轮的交换后放到后面了
     * @param a
     */
    public static void fun(int[] a){
        int num=0;
        int num1=0;
        for(int i=0;i<(a.length-1);i++){//执行了a.length次
            System.out.println("普通的方法排序执行外循环第:"+(i+1)+"次");
            for(int j=i+1;j<a.length;j++){
                num1++;
                if(a[i]>a[j]){//i位和后面的所有位比较,选出最小放在i位上
                    num++;
                    t=a[i];
                    a[i]=a[j];
                    a[j]=t;
                }
            }
        }
        //输出排序后的数组
        System.out.println("普通的方法排序执行数据交换:"+num+"次"+"==比较次数:"+num1);
        for(int c:a){
            System.out.print(c+",");
        }
    }
    
    /**
     * 2.普通的冒泡排序(后面有优化后的)
     * 时间复杂度:O(n*n)
     * @param a
     */
    public static void bubbleSort(int[] a){
        int num=0;
        int num1=0;
        for(int i=a.length-1;i>0;i--){
            System.out.println("普通冒泡执行外循环第:"+(a.length-i)+"次");
            for(int j=0;j<i;j++){
                num1++;
                if(a[j]>a[j+1]){
                    num++;
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        }
        //输出排序后的数组
        System.out.println("普通冒泡执行数据交换:"+num+"次"+"==比较次数:"+num1);
        for(int c:a){
            System.out.print(c+",");
        }
    }
    
    /**
     * 2.优化的冒泡排序
     * 例如
     * {1,2,3,4,5}数列已经是排好的,如果按上面冒泡排序,还是执行了所有循环,比较了n(n+1)/2次,根本没有必要
     * 所以我们在一次循环比较中,就要建立一个信号(如flag),标志这个数列是不是已经排好了
     * 
     * 最优时间复杂度:O(n);最差O(n*n)
     * @param a
     */
    public static void goodBubbleSort(int[] a){
        int num=0;
        int num1=0;
        boolean flag=true;//flag标志
        for(int i=a.length-1;i>0&&flag;i--){
            flag=false;//循环开始时候,把flag=false;
            System.out.println("优化冒泡排序执行外循环第:"+(a.length-i)+"次");
            for(int j=0;j<i;j++){
                num1++;
                if(a[j]>a[j+1]){
                    num++;
                    t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                    flag=true;//如果这次循环有交换,则flag为true,继续下一次循环
                }
            }
        }
        //输出排序后的数组
        System.out.println("优化冒泡执行数据交换:"+num+"次"+"==比较次数:"+num1);
        for(int c:a){
            System.out.print(c+",");
        }
    }
}

 

以上是关于冒泡排序的主要内容,如果未能解决你的问题,请参考以下文章

java冒泡排序法代码

python代码实现鸡尾酒排序(双向冒泡排序)

冒泡排序python代码

视频+图文+动画详解冒泡排序

交换排序(冒泡排序快速排序的算法思想及代码实现)

C语言冒泡排序。