八大排序算法~冒泡排序

一、基本介绍

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

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

二、图解冒泡排序算法的过程

注意：如果我们发现在某趟排序中，没有发生一次交换，就可以提前结束冒泡排序，这个就是优化。 

代码实现：

public static void main(String[] args) {
        int[] array = {3,9,-1,10,-2};
        //时间复杂度O(n^2)
        for(int i = 0; i < array.length-1; i++){
            int temp;
            for(int j = 0; j < array.length-1-i; j++){
                if(array[j] > array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"趟排序的结果是："+Arrays.toString(array));
        }
    }

结果展示：

冒泡排序优化：

import java.util.Arrays;

//冒泡排序
public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {3,9,-1,10,-2};
        //时间复杂度O(n^2)
        int temp;
        boolean flag = false;
        for(int i = 0; i < array.length-1; i++){
            for(int j = 0; j < array.length-1-i; j++){
                if(array[j] > array[j+1]){
                    flag = true;
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
            if(!flag){  //在一趟排序中，依次都没有交换过
                break;
            }else {
                flag = false;  //重置flag,进行下次判断
            }
            System.out.println("第"+(i+1)+"趟排序的结果是："+Arrays.toString(array));
        }
    }
}

 封装成一个方法

//封装成一个方法
    public static void getBubbleSort(int[] array){
        int temp = 0;
        boolean flag = false;
        for(int i = 0; i < array.length-1; i++){
            for(int j = 0; j < array.length-1-i; j++){
                if(array[j] > array[j+1]){
                    flag = true;
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
            if(!flag){
                break;
            }else {
                flag = false;
            }
        }
    }

测试：

 public static void main(String[] args) {
        int[] array = {3,9,-1,10,-2};
        System.out.println("排序前："+Arrays.toString(array));
        getBubbleSort(array);
        System.out.println("排序后："+Arrays.toString(array));
    }

结果：

 测试冒泡排序的速度：

public static void main(String[] args) {
//        int[] array = {3,9,-1,10,-2};
//        System.out.println("排序前："+Arrays.toString(array));
        //测试冒泡排序的速度
        int[] array = new int[80000];
        for(int i = 0; i < 80000; i++){
            array[i] =(int) (Math.random() * 80000);   //生成一个[0,10000)数
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间："+data1Str);

        getBubbleSort(array);   //冒泡排序
        Date date2 = new Date();
        String data2Str = simpleDateFormat.format(date2);
        System.out.println("排序前的时间："+data2Str);
        
    }

结果展示：