冒泡排序

Posted 2020-08-07

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

测试代码（输出比较次数，数据交换次数）：

测试类：

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+",");
        }
    }
}