常用排序算法

排序算法

排序算法的稳定性

假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

堆排序、快速排序、希尔排序、直接选择排序是不稳定的排序算法，

而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。

是稳定的排序算法。

/**
 * @description: 排序算法
 * @author: lld
 * @create: 2021-06-10 16:52
 **/
public class SortUtil {
    /**
     * @Description: 交换数组中两个元素位置
     * @Param: [arr, i, j]
     * @return: void
     **/
    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * @Description: 打印数组中所有元素
     * @Param: [arr]
     * @return: void
     **/
    public static void print(int[] arr) {
        for (int a : arr) {
            System.out.print(a + " ");
        }
        System.out.println();
    }

    /**
     * @Description: 冒泡排序
     * 平均时间复杂度  最好时间复杂度 最坏时间复杂度  空间复杂度
     * O(n^2)          O(n)          O(n^2)         O(1)
     * @Param: [arr]
     * @return: void
     **/
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    /**
     * @Description: 选择排序
     * 平均时间复杂度  最好时间复杂度 最坏时间复杂度  空间复杂度
     * O(n^2)          O(n^2)          O(n^2)         O(1)
     * @Param: [arr]
     * @return: void
     **/
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    swap(arr, i, j);
                }
            }
        }
    }

    /**
     * @Description: 插入排序
     * 平均时间复杂度  最好时间复杂度 最坏时间复杂度  空间复杂度
     * O(n^2)          O(n)          O(n^2)         O(1)
     * @Param: [arr]
     * @return: void
     **/
    public static void insertSort(int[] arr) {
//        从下标为1开始插入到前面的有序数组中
        int cur, j;
        for (int i = 1; i < arr.length; i++) {
            cur = arr[i];
            j = i;
//            当前面那个元素更小，不需要插入
            if (arr[j - 1] > cur) {
                while (j > 0 && cur < arr[j - 1]) {
//                将前一个元素值赋值给当前元素
                    arr[j] = arr[j - 1];
                    j--;
                }
            }
            arr[j] = cur;
        }
    }

    /**
     * @Description: 快速排序中拆分左右两个有序数组
     * @Param: [arr, l, r]
     * @return: int
     **/
    public static int partition(int[] arr, int l, int r) {
//        把第一个元素作为比较的基准值p
        int p = arr[l];
        int left = l;
        int right = r;
        while (left < right) {
//            从右往左找到第一个小于等于基准值p的元素位置right
            while (left < right && p < arr[right]) {
                right--;
            }
//            从左往右找到第一个小于基准值p的元素位置left
            while (left < right && p >= arr[left]) {
                left++;
            }
//            交换
            if (left < right) {
                swap(arr, left, right);
            }
        }
//        最后交换基准值与left
        swap(arr, left, l);
        return left;
    }

    /**
     * @Description: 快速排序
     * 平均时间复杂度  最好时间复杂度 最坏时间复杂度  空间复杂度
     * O(nlogn)          O(nlogn)      O(n^2)         O(logn)
     * @Param: [arr, left, right]
     * @return: void
     **/
    public static void quickSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int partition = partition(arr, left, right);
//       向左递归
        quickSort(arr, left, partition - 1);
//       向右递归
        quickSort(arr, partition + 1, right);
    }

    /**
     * @Description: 二分法插入排序是在插入第i个元素时，对前面的0～i-1元素进行折半，
     * 先跟他们中间的那个元素比，如果小，则对前半再进行折半，否则对后半进行折半，
     * 直到 left>right，然后再把第i个元素前1位与目标位置之间的所有元素后移，再把第i个元 素放在目标位置上。
     * 平均时间复杂度  最好时间复杂度 最坏时间复杂度  空间复杂度
     * O(nlogn)                                       O(1)
     * @Param: [arr]
     * @return: void
     **/
    public static void binaryInsertSort(int[] arr) {
        int left, right, mid;
        int temp;
        for (int i = 1; i < arr.length; i++) {
            left = 0;
            right = i - 1;
            temp = arr[i];
            while (left <= right) {
                mid = (left + right) / 2;
                if (temp > arr[mid]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
//            让left到当前位置i之间的元素右移
            for (int j = i - 1; j >= left; j--) {
                arr[j + 1] = arr[j];
            }
            arr[left] = temp;
        }
    }

    /**
     * @Description: 构建大顶堆
     * @Param: [arr]
     * @return: void
     **/
    public static void buildBigHeap(int[] arr) {
        //从最后一个非叶子节点开始
        for (int i = (arr.length - 1) / 2; i >= 0; i--) {
            downAdjust(arr, i, arr.length);
        }
    }

    /**
     * @Description: 下沉调整成大顶堆
     * 数组对应二叉树特点：下标i的父节点：(i-1)/2
     * i的子节点：2*i+1,2*i+2
     * @Param: [arr, parentIndex, length]
     * @return: void
     **/
    private static void downAdjust(int[] arr, int parentIndex, int length) {
        int temp = arr[parentIndex];
        int childIndex = parentIndex * 2 + 1;//左孩子索引
        while (childIndex < length) {
//            如果有右孩子，并且右孩子值>左孩子
            if (childIndex + 1 < length && arr[childIndex + 1] > arr[childIndex]) {
                childIndex++;//右孩子
            }
//            所有孩子都小，跳出
            if (temp >= arr[childIndex]) {
                break;
            }
            //让父节点=子节点的值
            arr[parentIndex] = arr[childIndex];
            parentIndex = childIndex;
            childIndex = childIndex * 2 + 1;
        }
        arr[parentIndex] = temp;
    }

    /**
     * @Description: 堆排序
     * 平均时间复杂度  最好时间复杂度 最坏时间复杂度  空间复杂度
     * O(nlogn)          O(nlogn)     O(nlogn)         O(n)
     * @Param: [arr]
     * @return: void
     **/
    public static void heapSort(int[] arr) {
//        先构建大顶堆
        buildBigHeap(arr);
//        每次交换第一个元素与最后一个元素
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
//        再进行调整，构建大顶堆操作
            downAdjust(arr, 0, i);
        }
    }

    /**
     * @Description: 希尔排序，又缩小增量排序
     * 平均时间复杂度  最好时间复杂度 最坏时间复杂度  空间复杂度
     * O(n^1.3)                                     O(1)
     * @Param: [arr]
     * @return: void
     **/
    public static void shellSort(int[] arr) {
        int len = arr.length;
//        每次增量减半
        for (int gap = len / 2; gap > 0; gap /= 2) {
//            相当于每次选择一个起始点，代表不同组
            for (int n = 0; n < gap; n++) {
//                进行间隔为gap的插入排序,gap+n代表从第二个数开始
                for (int i = gap + n; i < len; i += gap) {
                    int cur = arr[i];
                    int j = i;
                    if (arr[j - gap] > cur) {
                        while (j - gap >= 0 && arr[j - gap] > cur) {
                            arr[j] = arr[j - gap];
                            j -= gap;
                        }
                    }
                    arr[j] = cur;
                }
            }
        }
    }
}