排序算法 - 冒泡排序过程及优化

冒泡排序

冒泡排序：重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

类似与有两个指针指向想邻的两个元素，比较这两个元素（上面的是比较大小，大的元素移动到右边）

第一趟排序：

• 2与-1比较，2比-1大，2移动到右边 [-1, 2, 8, -5, 10]，指针后移，指向第二、第三位置
• 2与8比较，8比2大，不移动 [-1, 2, 8, -5, 10]，指针后移，指向第三、第四位置
• 8与-5比较，8比-5大，8移动到右边 [-1, 2, -5, 8, 10]，指针后移，指向第四、第五位置
• 8与10比较，8比10小，不移动 [-1, 2, 8, -5, 10]

第一趟比较，比较了4次，最终确定了数组最大的数
继续后续比较，一共比较4趟，排序后的数组的[-5, -1, 2, 8, 10]

---

Java显示冒泡过程

package com.company.sort;

import java.util.Arrays;

/**
 * @author zfk
 * 冒泡排序及优化
 */
public class BubbleSort {

    public static void main(String[] args) {
        int[] arr= {2,-1,8,10,-5};

        //临时变量
        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));

    }
}

因为上面是显示冒泡过程，把4个for循环拆开

合起来就是两个for循环嵌套

  public class BubbleSort {

    public static void main(String[] args) {
        int[] arr= {2,8,-1,10,-5};

        //临时变量
        int temp = 0;
        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("第"+(i+1)+"趟排序："+ Arrays.toString(arr));
        }
  }

---

冒泡排序优化

当冒泡排序有一趟排序，所有的元素都没有变动时，就表示该元素列已经有序

如上述，第四趟排序时后，如果再进行一趟排序，会发现所有元素都不会变动，即当我们发现排序过程中元素不会变动，可以结束排序

实现思路：设置一个临时变量flag，初始为false，当元素改变时置为true，每一躺排序都判断一次flag，当flag为false，就结束排序

前面的案例看不出，可以换成2,-1,8,10,20

public class BubbleSort {

    public static void main(String[] args) {
        int[] arr= {2,-1,8,10,20};

        //临时变量
        int temp = 0;
        //标识变量：表示是否进行过交换
        boolean flag = false;
        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]) {
                    //如果进入过该if判断，设置为true
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"趟排序："+ Arrays.toString(arr));
            if (flag == false){
                //在一趟排序过程中，一次交换都没有发生
                System.out.println("完成了排序，数组："+Arrays.toString(arr));
                break;
            }
            else {
                flag = false;
            }
        }
  	}

第一趟排序后数组已经有序，第二趟排序发现元素没有改变，即退出排序

---

冒泡排序时间复杂度

我们知道冒泡排序有两个for循环，即时间复杂度为O(n^2)，关于时间复杂度可以看：需要了解的时间复杂度、空间复杂度

可以算一下排序较大的数据量需要多少时间，再去比较其他的算法

稍微处理一下程序：

package com.company.sort;

import java.util.Arrays;
import java.util.Date;

/**
 * @author zfk
 * 冒泡排序及优化
 */
public class BubbleSort {

    public static void main(String[] args) {
        int[] arr = new int[8000];
        for(int i = 0 ;i <arr.length;i++){
            //随机生成80000内的整数
            arr[i] = (int) (Math.random()*80000);
        }
        Date dataBefore = new Date();

        bobbleSort(arr);

        Date dateAfter = new Date();

        System.out.println("消耗了："+(dateAfter.getTime()-dataBefore.getTime())+"ms");


    }

    public static void bobbleSort(int[] arr){
        //临时变量
        int temp = 0;
        //标识变量：表示是否进行过交换
        boolean flag = false;
        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]) {
                    //如果进入过该if判断，设置为true
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            //System.out.println("第"+(i+1)+"趟排序："+ Arrays.toString(arr));
            if (flag == false){
                //在一趟排序过程中，一次交换都没有发生
                //System.out.println("完成了排序，数组："+Arrays.toString(arr));
                break;
            }
            else {
                flag = false;
            }
        }
    }
}

对于8000个0~80000内的数据排序，消耗了124ms，总的来说还是比较慢的，因为时间复杂度是O(n^2)，是比较高的