简单排序算法：冒泡排序（交换排序）

冒泡排序：是一种交换排序。

基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

在不断循环的过程中，不仅将最小的关键字放到第一的位置，还将较小的关键字的位置提升了，较小的数字如同气泡般浮到上面。

import java.util.Arrays;public class Solution {    public static void main(String[] args) {        Solution s = new Solution();        int[] arr = {4,5,1,6,2,7,3,8,8,4};        s.BubbleSort(arr);        System.out.println(Arrays.toString(arr));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]    }    private void BubbleSort(int[] arr)    {     for (int i = 0; i < arr.length - 1; i++)     {         for (int j = arr.length - 2; j >= i; j--)         {             if (arr[j] > arr[j + 1])                 swap(arr, j, j + 1);         }     }    }    private void swap(int[] arr, int i, int j)    {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }}

冒泡算法的改进：

增加一个标记变量flag，如果有数据交换，则flag为true。没有任何数据交换的情况下说明序列已经有序，不需要再继续后面的循环判断工作。

import java.util.Arrays;public class Solution {    public static void main(String[] args) {        Solution s = new Solution();        int[] arr = {4,5,1,6,2,7,3,8,8,4};        s.BubbleSort(arr);        System.out.println(Arrays.toString(arr));    //输出：[1, 2, 3, 4, 4, 5, 6, 7, 8, 8]    }    private void BubbleSort(int[] arr)    {        boolean flag = true;        for (int i = 0; i < arr.length - 1 && flag; i++)        {            flag = false;            for (int j = arr.length - 2; j >= i; j--)            {                if (arr[j] > arr[j + 1])                {                    swap(arr, j, j + 1);                    flag = true;                }            }        }    }    private void swap(int[] arr, int i, int j)    {        int temp = arr[i];        arr[i] = arr[j];        arr[j] = temp;    }}

冒泡排序复杂度分析：

最好的情况下，排序的表本身是有序的，对改进后的冒泡排序，n-1次比较，没有数据交换，时间复杂度为O(n)。

最坏的情况下，排序的表是逆序的，需要比较1 + 2 + ... + (n-1) = n(n-1)/2次，并作等数量级的记录移动。时间复杂度为O(n^2)。