Java冒泡排序(Bubble Sort)和快速排序（Quick Sort）

LeetCode数组排序

• 912. 排序数组

冒泡排序(Bubble Sort)

• 时间复杂度O(n²)
• 空间复杂度O(1)

	//原理：比较两个相邻的元素，将值大的元素交换至右端。
    private void bubbleSort(int[] a) {
        //外循环为排序的趟数，每趟都会得到一个最大的数排在最后
        for (int i = 0; i < a.length - 1; i++) {
        	//内循环为每趟比较次数，第i次排序时，末尾已经排好了i个数，不需要重排
        	//也就是两两比较的次数
            for (int j = 0; j < a.length - 1 - i; j++) {
            	//两两比较，交换位置（大数放在后面）
                if (a[j] > a[j + 1]) {
                    int tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                }
            }
        }
    }

快速排序（Quick Sort）

• 时间复杂度平均O(nlogn)
• 常规写法

    /**
     * 快速排序（递归）
     * <p>
     * ①. 从数列中挑出一个元素，称为"基准"（pivot）。例如取左侧第一个数
     * ②. 重新排序数列，所有比基准值小的元素摆放在基准前面，
     * 		所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。
     * 		在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
     * ③. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
     *
     * @param arr  待排序数组
     * @param low  左边界
     * @param high 右边界
     */
    public void quickSort(int[] a, int low, int high) {
        if (a.length <= 0) return;
        if (low >= high) return;
        int left = low;
        int right = high;

        int key = a[left];   //挖坑1：保存基准的值
        while (left < right) {
            while (left < right && a[right] >= key) {  //坑2：从后向前找到比基准小的元素，插入到基准位置坑1中
                right--;
            }
            a[left] = a[right];
            while (left < right && a[left] <= key) {   //坑3：从前往后找到比基准大的元素，放到刚才挖的坑2中
                left++;
            }
            a[right] = a[left];
        }
        a[left] = key;   //基准值填补到坑3中，准备分治递归快排
        System.out.println("Sorting: " + Arrays.toString(a));
        
        quickSort(a, low, left - 1);
        quickSort(a, left + 1, high);
    }

• 快速排序，换一个思路清晰的写法
  直接交换，而非挖坑代填

    public void quickSort(int[] a, int low, int high) {
        if (a.length <= 1) return;
        if (low >= high) return;
        int left = low;
        int right = high;

        int key = a[left]; 
        while (left < right) {
        	//如果key右侧的数据比key大，则不需要交换
            while (left < right && a[right] >= key) {
                right--;
            }
            //右侧数据发现比key小的，直接交换
            swap(a, left, right);
            //交换后，key在右边了，判断左侧数据，比key小的不需要交换
            while (left < right && a[left] <= key) {
                left++;
            }
            //左侧数据比key大的，直接交换
            swap(a, left, right);
        }
        //此时，以key为分界线，将array分成了两部分
        System.out.println("Sorting: " + Arrays.toString(a));
        
        //分别对这两部分进行排序
        quickSort(a, low, left - 1);
        quickSort(a, left + 1, high);
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

总结

• 快速排序是在冒泡排序的基础上改进而来的，冒泡排序每次只能交换相邻的两个元素，而快速排序是跳跃式的交换，交换的距离很大，因此总的比较和交换次数少了很多，速度也快了不少。
• 快速排序在最坏情况下的时间复杂度和冒泡排序一样，是 O(n2)，实际上每次比较都需要交换，但是这种情况并不常见。我们可以思考一下如果每次比较都需要交换，那么数列的平均时间复杂度是 O(nlogn)，事实上在大多数时候，排序的速度要快于这个平均时间复杂度。这种算法实际上是一种分治法思想，也就是分而治之，把问题分为一个个的小部分来分别解决，再把结果组合起来。
• 快速排序只是使用数组原本的空间进行排序，所以所占用的空间应该是常量级的，但是由于每次划分之后是递归调用，所以递归调用在运行的过程中会消耗一定的空间，在一般情况下的空间复杂度为 O(logn)，在最差的情况下，若每次只完成了一个元素，那么空间复杂度为 O(n)。所以我们一般认为快速排序的空间复杂度为 O(logn)。
• 快速排序是一个不稳定的算法，在经过排序之后，可能会对相同值的元素的相对位置造成改变。
• 快速排序基本上被认为是相同数量级的所有排序算法中，平均性能最好的。

参考资料

• 快速排序算法详解（原理、实现和时间复杂度）
• 菜鸟教程排序 —— 快速排序