一. 原理

冒泡排序应该是大多数人接触的第一种排序方法，虽然它的时间复杂度为O（n^2），但是它简单易懂，代码复杂度低，所以仍有很大的用武之地。最近在总结排序算法，决定重温下冒泡排序，以及它的优化方法。

冒泡排序的一些属性：

算法	最好时间	最坏时间	平均时间	额外空间	稳定性
冒泡	O（n）	O（n^2）	O（n^2）	1	稳定

二. 原理动画展示

优化版冒泡排序，详细代码请关注CSDN id号 m0

三. 代码演示

优化版的冒泡排序比原版运行时间更短，效率更高，设置一个标志位，记录上一次交换，有交换继续循环，没有交换就提前结束。

package com.jackie03;

import java.util.Arrays;

/**
 * 优化冒泡排序算法：
 * 整个数列分成两个部分，前面有序，后面无序
 */

public class TestBubble {
    public static void main(String[] args) {
            int[] a = new int[5];
            int temp = 0;
            for(int i = 0;i<5;i++){
                a[i] = (int)(Math.random()*100);
            }
            for(int a1:a){
                System.out.print(a1+"\t");
            }
        System.out.println();

           //外层循环：n个元素排序，则至多需要n-1趟循环
            for(int i = 0;i<a.length-1;i++){
                boolean flag = true;        //定义一个布尔类型变量，标记数组是否已达到有序状态
                for(int j = 0;j<a.length-i-1;j++){
                    if(a[j]<a[j+1]){
                        temp = a[j];
                        a[j] = a[j+1];
                        a[j+1] = temp;
                        flag = false;       //本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较。
                    }
                }
                if(flag){
                    break;                  //根据标记量的值判断数组是否有序，有序则退出，无序则继续。
                }
            }
            for(int a1:a){
                System.out.print(a1+"\t");
            }
    }
}

四. 总结

给定一个无序数组，让“重”的元素下沉，轻的元素上浮”，这个就是冒泡排序。算法入门必备基础算法，明白其原理，不需要死记代码，要用的时候或者面试前，将其复习一下就好。

特附上冒泡排序初始版和快速排序：

Ⅰ.冒泡排序

public class demo_sort {
public static void main(String[] args) {
//冒泡排序算法
int[] numbers=new int[]{1,5,8,2,3,9,4};
//需进行length-1次冒泡
for(int i=0;i<numbers.length-1;i++)
{
for(int j=0;j<numbers.length-1-i;j++)
{
if(numbers[j]>numbers[j+1])
{
int temp=numbers[j];
numbers[j]=numbers[j+1];
numbers[j+1]=temp;
}
}
}
System.out.println("从小到大排序后的结果是:");
for(int i=0;i<numbers.length;i++)
System.out.print(numbers[i]+" ");
}
}

Ⅱ.快排

public class QuickSort {
public static void quickSort(int[] arr,int low,int high){
int i,j,temp,t;
if(low>high){
return;
}
i=low;
j=high;
//temp就是基准位
temp = arr[low];

while (i<j) {
//先看右边，依次往左递减
while (temp<=arr[j]&&i<j) {
j--;
}
//再看左边，依次往右递增
while (temp>=arr[i]&&i<j) {
i++;
}
//如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}

}
//最后将基准为与i和j相等位置的数字交换
arr[low] = arr[i];
arr[i] = temp;
//递归调用左半数组
quickSort(arr, low, j-1);
//递归调用右半数组
quickSort(arr, j+1, high);
}

public static void main(String[] args){
int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
quickSort(arr, 0, arr.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}