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

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

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

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

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)。