冒泡排序(Bubble Sort) & 快速排序(Qucik Sort)

冒泡排序(Bubble Sort)

什么是冒泡排序？
冒泡排序（Bubble Sort） 最为简单的一种排序，通过重复走完数组的所有元素，通过打擂台的方式两个两个比较，直到没有数可以交换的时候结束这个数，再到下个数，直到整个数组排好顺序。因一个个浮出所以叫冒泡排序。双重循环时间 O(n^2)

算法描述：

（此处以正序为例）

1. 比较相邻两个数据如果。第一个比第二个大，就交换两个数；
2. 对每一个相邻的数做同样1的工作，这样从开始一队到结尾一队在最后的数就是最大的数；
3. 针对所有元素上面的操作，除了最后一个；
4. 重复1~3步骤，知道顺序完成；

代码可视化：

代码实现：

    // 此类子为正序排序
    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length <= 0) {
            return;
        }
        for (int i = 0; i < arr.length; i ++) {
            for (int j = i + 1; j < arr.length; j ++) { // j = i + 1 相邻元素
                if (arr[i] > arr[j]) {
                    int tem = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tem;
                }
            }
        }
    }

冒泡排序复杂度分析
分析一下它的时间复杂度。当最好的情况，也就是要排序的表本身就是有序的，那么我们比较次数，那么可以判断出就是n-1次的比较，没有数据交换，此时时间复杂度为O(n)。当最坏的情况，即待排序是逆序的情况时间复杂度为 O(n^2)。

快速排序(Qucik Sort)

直接贴百科的，简单了解下即可，重要的是思想，是冒泡排序的升级版（思想很像）。

快速排序由C. A. R.
Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

算法描述：

1. 在待排序的元素任取一个元素作为基准(通常选第一个元素，称为基准元素）
2. 将待排序的元素进行分块，比基准元素大的元素移动到基准元素的右侧，比基准元素小的移动到作左侧，从而一趟排序过程，就可以锁定基准元素的最终位置
3. 对左右两个分块重复以上步骤直到所有元素都是有序的（递归过程）

算法步骤：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j；
(3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。
找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

算法可视化：

代码实现：

   public static void quickSort(int[] arr) {
        if (arr == null || arr.length <= 0) {
            return;
        }
        // 从第一个元素为基准值开始
        quickSort(arr, 0, arr.length - 1);
    }
    public static void quickSort(int[] arr, int left, int right) {
        int flag = arr[left]; // 第一个元素为基准值
        int i = left, j = right;
        while (i < j) { // 开始比较，相遇退出
            while (i < j && arr[j] >= flag) { // 顺序很重要，先从右侧开始找
                j--;
            }
            while (i < j && arr[i] <= flag) { // 在找左侧的
                i++;
            }
            // 交换两个数所在数组的位置，说明arr[i] > flag  arr[j] < flag；
            if (i < j) {
                int tem = arr[i];
                arr[i] = arr[j];
                arr[j] = tem;
            }
        }
        // 最终将基准值归位，放在第i个位置上
        arr[left] = arr[i];
        arr[i] = flag;

        // 左边快排
        if (left < i)
            quickSort(arr, left, i);
        // 右边快排
        if (right > i + 1)
            quickSort(arr, i + 1, right);
    }

具体算法执行流程如下：

快速排序封装后的代码如下：

package com.learn.science.algorithm.zhijian.quciksort;

/**
 * @author ZMJ
 * @date 2021/2/10
 */
public class quciksort {
    /**
     详解快排思想
     核心思想:
     1.在待排序的元素任取一个元素作为基准(通常选第一个元素，称为基准元素）
     2.将待排序的元素进行分块，比基准元素大的元素移动到基准元素的右侧，比基准元素小的移动到作左侧，从而一趟排序过程，就可以锁定基准元素的最终位置
     3.对左右两个分块重复以上步骤直到所有元素都是有序的（递归过程）
     */
    /* 快速排序主函数 */
    void sort(int[] nums) {
        // 一般要在这用洗牌算法将 nums 数组打乱，
        // 以保证较高的效率，我们暂时省略这个细节
        quicksort(nums, 0, nums.length - 1);
    }
    /* 快速排序核心逻辑 */
    public void quicksort(int[] nums, int lo, int hi) {
        if (lo >= hi) return;
        // 通过交换元素构建分界点索引 p
        int p = partition(nums, lo, hi);
        // 现在 nums[lo..p-1] 都小于 nums[p]，
        // 且 nums[p+1..hi] 都大于 nums[p]
        quicksort(nums, lo, p - 1);
        quicksort(nums, p + 1, hi);
    }
    public int partition(int[] nums, int lo, int hi) {
        if (lo == hi) return lo;
        // 将 nums[lo] 作为默认分界点 pivot
        int pivot = nums[lo];
        // j = hi + 1 因为 while 中会先执行 --
        int i = lo, j = hi + 1;
        while (true) {
            // 保证 nums[lo..i] 都小于 pivot
            while (nums[++i] < pivot) {
                if (i == hi) break;
            }
            // 保证 nums[j..hi] 都大于 pivot
            while (nums[--j] > pivot) {
                if (j == lo) break;
            }
            if (i >= j) break;
            // 如果走到这里，一定有：
            // nums[i] > pivot && nums[j] < pivot
            // 所以需要交换 nums[i] 和 nums[j]，
            // 保证 nums[lo..i] < pivot < nums[j..hi]
            swap(nums, i, j);
        }
        // 将 pivot 值交换到正确的位置
        swap(nums, j, lo);
        // 现在 nums[lo..j-1] < nums[j] < nums[j+1..hi]
        return j;
    }
    // 交换数组中的两个元素
    void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

}