数据结构与算法(11):冒泡排序(应用实例分析)

一:冒泡排序的基本介绍

  冒泡排序（Bubble Sorting）的基本思想是：通过对待
排序序列从前向后（从下标较小的元素开始）,依次比较
相邻元素的值，若发现逆序则交换，使值较大
的元素逐渐从前移向后部，就象水底下的气泡一样逐渐
向上冒。

  因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下
来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行)

我们举一个具体的案例来说明冒泡法。我们将五个无序的数：3, 9, -1, 10, -2 使用冒泡排序法将其排成一个从小到大的有序数列。

思路分析:

1. 第一次排序,3没有9大,所以第一次不动,数组依然为3, 9, -1, 10, -2
2. 第二次9和-1比较,这里需要做一次交换所以数组为 3 -1 9 10 -2
3. 按这样的规律排第一趟排序后的顺序就是 3 -1 9 -2 10.这样就确定了最大的一个数.
   第二趟:相当于前四个数进行排序了
4. -1 3 9 -2 10 -->-1 3 9 -2 10 --> -1 3 -2 9 10
   第三趟:相当于前三个数进行排序了
5. -1 3 -2 9 10 --> -1 -2 3 9 10.
   第四趟: -2 -1 3 9 10
   最终排序完成.
   总结:冒泡排序规则
   (1) 一共进行(数组大小-1次)大的循环
   (2) 每一趟的排序的次数在逐渐减小
   (3) 如果说我们发现在某趟排序中,没有发生依次交换,可以提前结束冒泡排序,这个是优化的过程
   代码实现:

package com.qiu.sort;

import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import java.util.Arrays;

public class BubbleSort {
     
    public static void main(String[] args) {
     
        int arr[]  = {
     3,9,-1,10,-2};

        //冒泡排序的演变过程
        /*
        1.第一趟排序就是将最大的数排在最后
         */
        int temp =0;
        for (int j = 0; j < arr.length-1; j++) {
     
            //如果前面的数比后面的数大,交换
           if (arr[j]>arr[j+1]){
     
               temp  = arr[j] ;
               arr[j] =arr[j+1] ;
               arr[j+1] = temp;
           }
        }
        System.out.println("第一趟排序的输出:" + Arrays.toString(arr));

        //第二趟排序就是将第二大的数排序到倒数第二位
        for (int j = 0; j < arr.length-1-1; j++) {
     
            //如果前面的数比后面的数大,交换
            if (arr[j]>arr[j+1]){
     
                temp  = arr[j] ;
                arr[j] =arr[j+1] ;
                arr[j+1] = temp;
            }
        }
        System.out.println("第二趟排序的输出:" + Arrays.toString(arr));

        for (int j = 0; j < arr.length-1-2; j++) {
     
            //如果前面的数比后面的数大,交换
            if (arr[j]>arr[j+1]){
     
                temp  = arr[j] ;
                arr[j] =arr[j+1] ;
                arr[j+1] = temp;
            }
        }
        System.out.println("第三趟排序的输出:" + Arrays.toString(arr));

        for (int j = 0; j < arr.length-1-3; j++) {
     
            //如果前面的数比后面的数大,交换
            if (arr[j]>arr[j+1]){
     
                temp  = arr[j] ;
                arr[j] =arr[j+1] ;
                arr[j+1] = temp;
            }
        }
        System.out.println("第四趟排序的输出:" + Arrays.toString(arr));
    }
}

代码运行结果演示:

这里可以做一个优化:

    public static void main(String[] args) {
     
        int arr[]  = {
     3,9,-1,10,-2};
        int temp =0;
        //冒泡排序的演变过程
        /*
        1.第一趟排序就是将最大的数排在最后
         */
        for (int i =0; i<arr.length-1;i++){
     
            for (int j = 0; j < arr.length-1-i; j++) {
     
                //如果前面的数比后面的数大,交换
                if (arr[j]>arr[j+1]){
     
                    temp  = arr[j] ;
                    arr[j] =arr[j+1] ;
                    arr[j+1] = temp;
                }
            }
        }


        System.out.println("排序的输出:" + Arrays.toString(arr));

这里用了双层for循环进行排序,这里的时间复杂度为O(n^2)

这里可能在第二趟的时候就已经排好序了,但是算法依旧会去执行,所以我们需要对算法做优化

代码优化:

    public static void main(String[] args) {
     
        int arr[]  = {
     3,9,-1,10,-2};
        int temp =0;
        boolean flag = false;//标识变量,表示说如果两个数之间做了交换,那么这个flag会变
        //冒泡排序的演变过程
        /*
        1.第一趟排序就是将最大的数排在最后
         */
        for (int i =0; i<arr.length-1;i++){
     
            for (int j = 0; j < arr.length-1-i; j++) {
     
                //如果前面的数比后面的数大,交换
                if (arr[j]>arr[j+1]){
     
                    flag =true;
                    temp  = arr[j] ;
                    arr[j] =arr[j+1] ;
                    arr[j+1] = temp;
                }
            }
            if (!flag){
     
                //在交换过程中一次交换都没有发生过
                break;
            }else {
     
                flag =false;//重置flag进行下一次的判断
            }
        }


        System.out.println("排序的输出:" + Arrays.toString(arr));

    }
}

判断第一趟,第二趟…是否有交换过,如果没有交换直接退出里面一层的循环.

接着我们来看看冒泡排序处理多数据的时间:

  //测试一下冒泡排序的速度,给8w随机数组
        int[] arr1 = new int[80000];
        for (int i = 0; i < 80000; i++) {
     
            arr1[i] =(int)(Math.random()*80000000);

        }
        //测试排序时间
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = format.format(date);
        System.out.println("排序前的时间:"+dateStr);
        bubbleSort(arr1);

        Date date1 = new Date();
        SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr1 = format1.format(date1);
        System.out.println("排序前的时间:"+dateStr1);

代码运行:
大概是16秒时间.