【Java个人总结】七大基于比较的排序

♛红叶♛

已于 2022-03-03 15:39:53 修改

阅读量268

点赞数 2

文章标签： java 开发语言后端

于 2022-03-01 19:26:30 首次发布

本文链接：https://blog.csdn.net/qq_52080086/article/details/123213528

版权

在多数排序中，我们可以将排序过程中的数据划分为有序区间与无序区间。除了以下的七种基于比较的排序，还有一些基于非比较的排序：基数排序，计数排序，桶排序。

在这里插入图片描述

稳定性：两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。

交换排序

冒泡排序

冒泡排序是许多人第一个接触的排序算法，在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。该方法的排序过程与气泡从水中往上冒的情况很相似，所以被称作冒泡排序。

public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++){ //外层循环控制比较的轮数
            for(int j = 0; j < array.length - i - 1; j++){  //内层循环控制每一轮比较的次数
                //相等则不交换。保证其稳定性
                if(array[j] > array[j+1]){  //比较前后两数，交换。大数每一次比较都会交换到后一位
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }

快速排序

快速排序利用分治法来对待排序序列进行分治排序，设定一个基准值，通过一趟排序将待排记录分隔成独立的两部分，其中的一部分比基准值小，后面一部分比基准值大，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

public static void quickSort(int[] array){
        quickSortInternal(array, 0, array.length - 1);
    }
    private static void quickSortInternal(int[] array, int left, int right){
        if(left >= right){
            return;
        }
        //pivotIndex作为基准值最终停留的下标
        int pivotIndex = partition(array, left, right);
        // [left, pivotIndex - 1] 都是小于等于基准值的
        // [pivotIndex + 1, right] 都是大于等于基准值的
        quickSortInternal(array, left, pivotIndex - 1);
        quickSortInternal(array, pivotIndex + 1, right);
    }
    //该块作用是遍历整个待排序区间，小于基准值的放到基准值的左边，大于基准值的放到基准值的右边。
    private static int partition(int[] array, int left, int right){
        int i = left;
        int j = right;
        int pivot = array[left];    // 选择基准值最简单的方式，选择 array[left] 作为基准值

        while(i < j){
            while(i < j && array[j] >= pivot){  //从右往左直到找到比基准值小的数
                j--;
            }
            while(i < j && array[i] <= pivot){  //从左往右直到找到比基准值大的数
                i++;
            }
            //上述循环找到了符合条件的 i, j 后交换两数
            swap(array, i, j);
        }
        //将基准数放到中间位置
        swap(array, i, left);
        return i;
    }

    private static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

插入排序

直接插入排序

数据的整个区间被划分为有序区间与无序区间，每次选择无序区间内第一个元素，在有序区间中选择合适的位置放入。所以初始数据越接近有序，算法效率越高。

    public static void insertSort(int[] array){
        // 有序区间: [0, i)
        // 无序区间: [i, array.length)
        for(int i = 1; i < array.length; i++){
            int v = array[i];//无序区间第一个数
            int j = i - 1; //不使用j = v是为了保证排序的稳定性
            for(; j >= 0 && array[j] > v; j--){
                array[j+1] = array[j];
            }
            array[j+1] = v;
        }
    }

希尔排序

希尔排序又称缩小增量法，是对直接插入排序的一种优化，其基本思想是将待排序区间按某个增量gap划分为若干个组，对每个组的元素进行插入排序，随着gap的减小，数据越接近有序，当gap==1时，整个数据合成一组有序记录。

JMTZA`U%RLY3YR3%U~F(WNC[4]

public static void shellSort(int[] array){
        int gap = array.length;
        while(gap > 1){
            insertSortGap(array,gap);
            gap = gap / 2;
        }
        insertSortGap(array, 1);
    }
    public static void insertSortGap(int[] array, int gap){
        // 有序区间: [0, i)
        // 无序区间: [i, array.length)
        for(int i = 1; i < array.length; i++){
            int v = array[i];//无序区间第一个数
            int j = i - gap; //不使用j = v是为了保证排序的稳定性
            for(; j >= 0 && array[j] > v; j -= gap){
                array[j+gap] = array[j];
            }
            array[j+gap] = v;
        }
    }

选择排序

直接选择排序

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完。

public static void selectSort(int[] array){
        // 无序区间: [0, array.length - i)
        // 有序区间: [array.length - i, array.length)
        for(int i = 0; i < array.length - 1; i++){  //将最后一位作为初始有序区间
            int max = 0;
            for(int j = 0; j < array.length - i; j++){//选择无序区间中最大的值
                if(array[j] > array[max]){
                    max = j;
                }
            }
            //将选择出的最大值置换到有序区间
            int temp = array[array.length - i - 1];
            array[array.length - i - 1] = array[max];
            array[max] = temp;
        }
    }

堆排序

在说明堆排序之前，我们简单了解一下什么是堆。

堆逻辑上是一棵完全二叉树
堆物理上是保存在数组中
满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆
反之，则是小堆，或者小根堆，或者最小堆

此外，还要记住二叉树的下标关系：

左孩子(left)下标 = 2 * parent + 1;
右孩子(right)下标 = 2 * parent + 2

直接选择排序通过遍历的方式寻找无序区间内最大（或最小）的数，而堆排序是通过堆来选择无序区间的最大（或最小）数。

public static void heapSort(int[] array) {
        createHeap(array);  //构建一个大顶堆，保证数组第一个元素时最大的

        for(int i = 0; i < array.length - 1; i++){
            //交换0号元素与无序区间的最后一个元素
            swap(array,0, array.length - i - 1);
            //在交换后，数组末尾元素则为最大值，再一次遍历时应排除该元素，对无序区间重新构建一个大顶堆
            maxHeap(array,array.length - i - 1,0);
        }

    }
    private static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
    private static void createHeap(int[] array) {
        for(int i = (array.length - 1) / 2; i >= 0; i--){
            maxHeap(array, array.length, i);
        }
    }
	//大顶堆
    public static void maxHeap(int[] array, int heapSize, int index) {
        //二叉树的下标关系
        int left = 2 * index + 1;      //左孩子
        int right = 2 * index + 2;      //右孩子
        int max = index;

        //比较左子节点的值，如果比当前左节点的值大，则把最大值的位置换成左子节点的位置
        if(left < heapSize && array[left] > array[max]){
            max = left;
        }
        if(right < heapSize && array[right] > array[max]){
            max = right;
        }
        //如果不相等则说明其子节点存在更大的数值，则位置发生交换
        if(max != index){
            swap(array,index,max);
            // 交换完位置后还需要判断子节点是否打破了最大堆的性质。最大堆性质：两个子节点都比父节点小。
            maxHeap(array, heapSize, max);
        }

    }

注意：排升序要建大堆；排降序要建小堆。

归并排序

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

 private static void merge(int[] array, int low, int mid, int high) {
        int i = low;
        int j = mid + 1;
        int length = high - low;
        int[] extra = new int[length + 1];
        int k = 0;

        // 选择小的放入 extra
        while (i <= mid && j <= high) {
            // 加入等于，保证稳定性
            if (array[i] <= array[j]) {
                extra[k++] = array[i++];
            } else {
                extra[k++] = array[j++];
            }
        }

        // 将左边剩余元素放入 extra
        while (i <= mid) {
            extra[k++] = array[i++];
        }
        // 将右边剩余元素放入 extra
        while (j <= high) {
            extra[k++] = array[j++];
        }

        // 从 extra 搬移回 array
        for (int t = 0; t < extra.length; t++) {
            // 需要搬移回原位置，从 low 开始
            array[low + t] = extra[t];
        }
    }

    public static void mergeSort(int[] array) {
        mergeSortInternal(array, 0, array.length - 1);
    }
    // 待排序区间为 [low, high)
    private static void mergeSortInternal(int[] array, int low, int high) {
        if (low - 1 >= high) {
            return;
        }

        int mid = (low + high) / 2;
        if(low < high){
            mergeSortInternal(array, low, mid);
            mergeSortInternal(array, mid + 1, high);
            merge(array, low, mid, high);
        }
    }

各排序特点总结

排序方法	最好	平均	最坏	空间复杂度	稳定性
冒泡排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
直接插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
直接选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
希尔排序	O(n)	O(n^1.3)	O(n^2)	O(1)	不稳定
堆排序	O(n * log(n))	O(n * log(n))	O(n * log(n))	O(1)	不稳定
快速排序	O(n * log(n))	O(n * log(n))	O(n^2)	O(log(n)) ~ O(n)	不稳定
归并排序	O(n * log(n))	O(n * log(n))	O(n * log(n))	O(n)	稳定