04经典排序算法

参考文章:

• 图解算法数据结构-leetcode)

• 尚硅谷Java数据结构与java算法

• 十大经典排序算法 | 菜鸟教程 

排序算法时间复杂度

注意点:

• 「基数排序」适用于正整数、字符串、特定格式的浮点数排序，kk 为最大数字的位数；「桶排序」中 kk 为桶的数量

• 普通「冒泡排序」的最佳时间复杂度为 O(N^2) ，通过增加标志位实现 提前返回 ，可以将最佳时间复杂度降低至 O(N) 。

• 在输入列表完全倒序下，普通「快速排序」的空间复杂度劣化至 O(N) ，通过代码优化 Tail Call Optimization 保持算法递归较短子数组，可以将最差递归深度降低至 logN 。

• 普通「快速排序」总以最左或最右元素为基准数，因此在输入列表有序或倒序下，时间复杂度劣化至 O(N^2) ；通过 随机选择基准数 ，可极大减少此类最差情况发生，尽可能地保持 O(NlogN) 的时间复杂度。

• 若输入列表是数组，则归并排序的空间复杂度为 O(N) ；而若排序 链表 ，则「归并排序」不需要借助额外辅助空间，空间复杂度可以降低至 O(1) 。

冒泡排序

    /**
     * 简单冒泡排序
     *
     * @param nums
     */
    public static void bubbleSort(int[] nums) {

        int N = nums.length;
        // 外循环
        for (int i = 0; i < N - 1; i++) {
            // 内循环
            for (int j = 0; j < N - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    // 交换 nums[j], nums[j + 1]
                    int tmp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = tmp;
                }
            }

        }
    }

优化方式:

    /**
     * 优化的冒泡排序
     *
     * @param nums
     */
    public static void bubbleOptimizedSort(int[] nums) {
        int N = nums.length;
        for (int i = 0; i < N - 1; i++) {
            boolean flag = false; // 初始化标志位
            for (int j = 0; j < N - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    int tmp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = tmp;
                    flag = true;  // 记录交换元素
                }
            }
            if (!flag) break;     // 内循环未交换任何元素，则跳出
        }
    }

选择排序

    /**
     * 选择排序
     * @param arr
     */
    public static void selectSort(int[] arr){

        //1.外循环:每次循环选择一个最小的放到指定位置
        for (int i = 0; i < arr.length; i++){

            //2.内循环: 每次循环帅选出最小值
            int min = arr[i];  //默认i为当前最小值
            int index = i;     //记录最小值的索引
            for (int j = i + 1; j < arr.length; j++ ){
                if (arr[j] < min){
                    index = j;
                    min = arr[index];  //更新最小值
                }
            }

            //3.将最小值放到(交换)对应位置
            if (index != i){
                arr[index] = arr[i];
                arr[i] = min;
            }

        }
    }

插入排序

    //插入排序
    public static void insertSort(int[] arr) {

        int insertVal = 0;      //需要插入的值
        int insertIndex = 0;    //插入的位置
        //1.外部循环 每次循环插入一个数据
        for (int i = 1; i < arr.length; i++) {

            //2.内部循环 每次while循环查找到插入的位置
            insertVal = arr[i];  //定义待插入的数
            insertIndex = i - 1; //即arr[i]的前面这个数的下标
            // 给insertVal 找到插入的位置
            // 说明
            // 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
            // 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
            // 3. 就需要将 arr[insertIndex] 后移
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
                insertIndex--;
            }

            //2.当退出while循环时，说明插入的位置找到, insertIndex + 1
            if (insertIndex + 1 != i) { //这里我们判断是否需要赋值
                //这里为什么要 +1 存在两种场景
                //1.while循环未进入 此时因为i - 1 向前移动了一位， 所以需要 + 1
                //2.进入了while循环， 此时因为 循环退出时 insertIndex--; 向前移动了一位， 所以需要 + 1
                //3.因此最终处理数据时需要+1操作
                arr[insertIndex + 1] = insertVal;
            }

            System.out.println("第" + i + "轮插入");
            System.out.println(Arrays.toString(arr));
        }

    }

希尔排序

    //对交换式的希尔排序进行优化->移位法
    public static void shellSort2(int[] arr) {

        //1.进行分组
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {

            //2.将所有分组进行插入排序
            //此处循环做两件事:1.循环每个组内的数据排序 2.循环每个分组进行插入排序
            for (int i = gap; i < arr.length; i++) {

                //3.进行插入处理
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {

                    //4.向左移动坐标，查找需要插入的位置
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        //移动
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    //5.将数据插入到对应位置
                    arr[j] = temp;
                }

            }
        }
    }

快速排序实现代码 (使用递归)

package com.arithmetic;

import java.util.Arrays;
import java.util.stream.Collectors;

/**
 * @author mazhiyuan
 * @date 2022/01/06
 */
public class QuickSort {

    /**
     * @param arr
     * @param low
     * @param high
     */
    public static void quickSort(int[] arr, int low, int high) {

        // 1.递归截止条件 大于
        if (low > high) {
            return;
        }

        // 2.递归具体逻辑
        // 2.1递归数据处理逻辑（递归前处理）
        int mid = dealData(arr, low, high);

        // 2.2递归方法调用切点
        //递归调用左半数组
        quickSort(arr, low, mid - 1);
        //递归调用右半数组
        quickSort(arr, mid + 1, high);

    }

    /**
     * @param arr
     * @param low
     * @param high
     * @return int
     */
    private static int dealData(int[] arr, int low, int high) {
        int i, j, temp, t;
        i = low;
        j = high;
        //temp就是基准位
        temp = arr[low];
        while (i < j) {  // 小于
            //当选择左边作为基准 时必须从右边开始移动。 因为交换会将小的值交换到左边，基准值交换到右边 这样才符合从小到大排序。
            //先从右边，依次往左递减
            while (temp <= arr[j] && i < j) {
                j--;
            }
            //再从左边，依次往右递增
            while (temp >= arr[i] && i < j) {
                i++;
            }
            //如果满足条件则交换
            if (i < j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换 等于
        arr[low] = arr[i];
        arr[i] = temp;
        // i j 相等此处返回两者都可以， i, j 都为此次循环的中间值 / 中间位置
        return j;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 2, 4, 7, 62, 3, 4, 2, 1, 8, 9, 19};
//        int[] arr = {2, 1};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.stream(arr).boxed().collect(Collectors.toList()));
    }
}

归并排序(使用递归)

package com.arithmetic;

import java.util.Arrays;


/**
 * @author mazhiyuan
 * @date 2022/01/07
 */
public class MergeSort {

    /**
     * @param arr
     */
    public static void sort(int[] arr) {
        //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
    }

    /**
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    private static void mergeSort(int[] arr, int left, int right, int[] temp) {

        //1.递归终止条件
        if (left >= right){
            return;
        }

        //2.递归方法调用切点
        int mid = (left + right) / 2;               //设置mid
        mergeSort(arr, left, mid, temp);            //左边归并排序，使得左子序列有序
        mergeSort(arr, mid + 1, right, temp);   //右边归并排序，使得右子序列有序

        //3.递归数据处理(合并数据)
        merge(arr, left, mid, right, temp);         //将两个有序子数组合并操作
    }

    /**
     * @param arr
     * @param left
     * @param mid
     * @param right
     * @param temp
     */
    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {

        //1.数据循环比较
        int i = left;       //左序列指针
        int j = mid + 1;    //右序列指针
        int t = 0;          //临时数组指针
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }

        //2.处理比较循环后剩余剩余数据(因为两边数据个数不一定相等)
        while (i <= mid) {//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while (j <= right) {//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }

        //3.将temp中的元素全部拷贝到原数组中
        t = 0; //重置临时数组坐标
        while (left <= right) {
            arr[left++] = temp[t++];
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

基数排序

package com.arithmetic.sort;

import java.util.Arrays;

/**
 * 基数排序
 *
 * @author mazhiyuan
 * @date 2022/01/13
 */
public class RadixSort {

    public static void main(String[] args) {
        int arr[] = {53, 3, 542, 748, 14, 214};

        //1.定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
        int[][] bucket = new int[10][arr.length];

        //2.为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
        int[] bucketElementCounts = new int[10];

        //3.进行基数排序
        radixSort(arr, bucket, bucketElementCounts);
        System.out.println("基数排序后 " + Arrays.toString(arr));

    }

    //基数排序方法
    public static void radixSort(int[] arr, int[][] bucket, int[] bucketElementCounts) {

        //0. 得到数组中最大的数的位数
        int maxLength = getMaxLength(arr);

        //1.外循环 基数排序次数 
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {

            //2.循环将数据放到不同的桶中
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的值
                int digitOfElement = arr[j] / n % 10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            }

            //3.遍历每一桶，并将桶中是数据，放入到原数组
            int index = 0;
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中，有数据，我们才放入到原数组
                if (bucketElementCounts[k] != 0) {
                    //循环该桶即第k个桶(即第k个一维数组), 放入
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        //取出元素放入到arr
                        arr[index++] = bucket[k][l];
                    }
                }
                //第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
                bucketElementCounts[k] = 0;

            }
            System.out.println("第" + (i + 1) + "轮，对个位的排序处理 arr =" + Arrays.toString(arr));

        }


    }

    /**
     * 获取长度
     *
     * @param arr
     * @return int
     */
    private static int getMaxLength(int[] arr) {
        //1. 得到数组中最大的数的位数
        int max = arr[0]; //假设第一数就是最大数
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength = (max + "").length();
        return maxLength;
    }
}