十大排序算法---冒泡排序

冒泡排序是排序算法中最简单的一种，比较容易理解。




代码实现：

/*
冒泡排序步骤：
    ①遍历整个数组，比较相邻两个位置的元素，如果前面的元素比后面的元素值大，
    则交换两个元素的位置(从大到小排序相反)，找出数组中最大的那个元素。
    ②再以相同的方法从剩余的元素中找出最大值
    ③重复第②步
分析：
    第一轮遍历数组，可以找出最大值，第一轮结束后，最后一个元素已经是最大值了，所以可以不用参与比较。
    然后再遍历剩余元素，找出最大值，反复执行这一步
    
时间复杂度= O(n²)
空间复杂度= O(1)
*/

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1,35,12,33,25,36,7,10,100,23};
        bubbleSort(arr);
    }


    /**
     * 从小到大排序
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    /**
     * 从大到小排序
     * @param arr
     */
    public static void bubbleSort1(int[] arr){
        for (int k = 0; k < arr.length; k++) {
            for (int j = 0; j < arr.length - 1 - k; j++) {
                if (arr[j] < arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

冒泡排序可以做一个简单的优化。
假如我们给一个基本上有序的数组，第一轮交换之后数组实际上已经有序了，这个时候我们就不必再让程序继续跑了，可以提前结束。

实现方式:
做一个标记，每一轮结束之后都对查看一下这个标记。

public void improveBubbleSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            boolean sorted = true;//做一个标记,每一轮都默认是有序的
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    //如果这个代码块执行，说明数组是无序的。
                    sorted = false;
                }
            }
            //每轮比较完成之后都会查看是否已经有序，如果已经有序，则可以提前结束比较。
            if (sorted) break;
        }
    }