排序

  • 开发
  • 23

排序的概念及引用

排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

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

在这里插入图片描述

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

排序运用

在这里插入图片描述

常见的排序算法

在这里插入图片描述

常见排序算法的实现

插入排序

基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到 一个新的有序序列 。实际中我们玩扑克牌时，就用了插入排序的思想。

在这里插入图片描述

直接插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

逻辑：

假设这组数据的第一个元素是有序的，从第二个元素开始，依次和前面的元素进行比较，找到合适的位置就进行插入+

在这里插入图片描述

/**
 * 时间复杂度：
 * 最坏情况下：O(n^2)  5   4   3   2   1
 * 最好情况下：O(n)   当数据越有序 排序越快   1  2  3  4  5
 * 适用于：待排序序列  已经基本上趋于有序了！
 * 空间复杂度：O(1)
 * 稳定性：稳定的
 *
 * @param array
 */
public static void insertSort(int[] array,int left,int right) {
    //left = 0; right = array.length;
    for (int i = left + 1; i <= right; i++) {
        int tmp = array[i];
        int j = i - 1;
        for (; j >= left; j--) {
            //这里加不加等号  和稳定有关系
            //但是 本身就是一个稳定的排序 可以实现为不稳定的排序
            //但是 本身就是一个不稳定的排序 是不可能变成一个稳定的排序的
            if (array[j] > tmp) {
                array[j + 1] = array[j];
            } else {
                //array[j+1] = tmp;
                break;
            }
        }
        array[j + 1] = tmp;
    }
}

【直接插入排序的特性总结】：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

希尔排序( 缩小增量排序 )

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成多个组， 所有距离为的记录分在同一组内，并对每一组内的记录进行排序（每组采用的是直接插入排序）。然后，取，重复上述分组和排序的工作。当到达 =1时，所有记录在统一组内排好序。

在这里插入图片描述

public static void shellSort(int[] array) {
    int gap = array.length;
    while (gap > 1) {
        //初始间隔为数组长度的一半
        gap /= 2;
        //对每个间隔进行插入排序
        shell(array, gap);
    }
}

/**
 * 对每组进行插入排序
 *
 * @param array
 * @param gap
 */
private static void shell(int[] array, int gap) {
    //从第 gap 个元素，逐个对其所在组进行直接插入排序操作
    for (int i = gap; i < array.length; i++) {
        int tmp = array[i];
        int j = i - gap;
        // 插入排序的逻辑，以间隔 gap 进行比较和移动
        for (; j >= 0; j -= gap) {
            if (array[j] > tmp) {
                array[j + gap] = array[j];
            } else {
                //找到插入位置
                //array[j+1] = tmp;
                break;
            }
        }
        array[j + gap] = tmp;
    }
}

【希尔排序的特性总结】：

  1. 希尔排序是对直接插入排序的优化。

  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排 序的时间复杂度都不固定：

    《数据结构(C语言版)》— 严蔚敏

在这里插入图片描述

《数据结构-用面向对象方法与C++描述》— 殷人昆

在这里插入图片描述

因为gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照在这里插入图片描述

  1. 稳定性：不稳定

选择排序

基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

直接选择排序

  • 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
  • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

在这里插入图片描述

/**
 * 直接选择排序：
 * 时间复杂度：O(n^2)
 * 空间复杂度：O(1)
 * 稳定性：不稳定的排序
 *
 * @param array
 */
public static void selectSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        int minIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        swap(array, i, minIndex);
    }
}

public static void selectSort2(int[] array) {
    int left = 0;
    int right = array.length - 1;
    while (left < right) {
        int minIndex = left;
        int maxIndex = left;
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < array[minIndex]) {
                minIndex = i;
            }
            if (array[i] > array[maxIndex]) {
                maxIndex = i;
            }
        }
        swap(array, minIndex, left);
        //防止第一个是最大值，如果和最小的一换，最大值就跑到了原来最小值的位置
        if (maxIndex == left) {
            maxIndex = minIndex;
        }
        swap(array, maxIndex, right);
        left++;
        right--;
    }
}

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

【直接选择排序的特性总结】 ：

  1. 直接选择排序思考非常好理解，但是效率不是很好，实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆 来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

在这里插入图片描述

/**
     * 堆排序：
     * 时间复杂度：O(N*logN)
     * 空间复杂度：O(1)
     * 稳定性：不稳定的排序
     *
     * @param array
     */
    public static void heapSort(int[] array) {
        //创建大根堆
        createHeap(array);
        int end = array.length - 1;
        while (end > 0) {
            swap(array, 0, end);
            siftDown(array, 0, end);
            end--;
        }
    }

private static void createHeap(int[] array) {
        for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
            siftDown(array, 0, array.length);//alt+enter
        }
    }

    //向下调整
    private static void siftDown(int[] array, int parent, int length) {
        int child = 2 * parent + 1;
        while (child < length) {
            if (child + 1 < length && array[child] < array[child + 1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array, child, parent);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

【堆排序的特性总结】 ：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

交换排序

基本思想

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

冒泡排序

在这里插入图片描述

/**
 * 冒泡排序：
 * 时间复杂度：O(N^2)
 * 如果加了优化：最好情况下 可以达到O(n)
 * 空间复杂度：O(1)
 * 稳定性：稳定的排序
 * <p>
 * 优化：
 * 每一趟都需要判断 上一趟 有没有交换
 *
 * @param array
 */
public static void bubbleSort(int[] array) {
    //i代表的是趟数
    for (int i = 0; i < array.length - 1; i++) {
        boolean flg = false;
        //j来比较 每个数据的大小
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(array, j, j + 1);
                flg = true;
            }
        }
        if (!flg) {
            break;
        }
    }
}

【冒泡排序的特性总结】：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法。

基本思想为任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有 元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int[] array, int left, int right)
{
    if(right - left <= 1)
        return;
    
    // 按照基准值对array数组的 [left, right)区间中的元素进行划分
    int div = partion(array, left, right);
    
    // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
    // 递归排[left, div)
    QuickSort(array, left, div);
    
    // 递归排[div+1, right)
    QuickSort(array, div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：

  1. Hoare版
/**
 * 快速排序：
 * 时间复杂度：
 * 最好的情况下：O(N*logN)
 * 最坏情况下：O(N^2) 逆序/有序
 * 空间复杂度：
 * 最好的情况下：O(logN)
 * 最坏情况下：O(N) 逆序/有序
 * 稳定性：不稳定
 *
 * @param array
 */
public static void quickSort(int[] array) {
    quick(array, 0, array.length - 1);
}

private static void quick(int[] array, int start, int end) {
    if (start >= end) {
        return;
    }
    //System.out.println("start: "+start +" end: "+end);
    if(end - start + 1 <= 15) {
        insertSort(array, start, end); //直接插入排序
        return;
    }

    //优化：降低树的高度，但未解决栈溢出的问题
    //1 2 3 4 5 6 7
    int index = middleNum(array,start,end);
    swap(array,index,start);
    //4 2 3 1 5 6 7

    //int pivot = partitionHoare(array, start, end);
    //int pivot = partitionHole(array,start,end);
    int pivot = partition(array,start,end);
    quick(array, start, pivot - 1);
    quick(array, pivot + 1, end);
}

/**
 * 求中位数的下标
 * @param array
 * @param left
 * @param right
 * @return
 */
private static int middleNum(int[] array,int left,int right) {
    int mid = (left + right) / 2;
    if (array[left] < array[right]) {
        if (array[mid] <array[left]) {
            return left;
        }else if (array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        //array[left] > array[right]
        if(array[mid] < array[right]) {
            return right;
        }else if(array[mid] > array[left]) {
            return left;
        }else {
            return mid;
        }
    }
}

/**
 * 思考2个问题：
 * 1. array[right] >= tmp 等于号
 * 2. 为什么从右边开始而不是从左边开始
 *
 * @param array
 * @param left
 * @param right
 * @return
 */
private static int partitionHoare(int[] array, int left, int right) {
    int tmp = array[left];
    int i = left;

    while (left < right) {
        // 单独的循环 不能一直减到超过最左边的边界
        while (left < right && array[right] >= tmp) {
            right--;
        }
        while (left < right && array[left] <= tmp) {
            left++;
        }
        swap(array, left, right);
    }
    swap(array, i, left);
    return left;
}

/**
     * 前后指针法：
     *  总结：
     *  1. Hoare
     *  2. 挖坑法
     *  3. 前后指针法
     *  这3种方式  每次划分之后的前后顺序 有可能是不一样的
     * @param array
     * @param left
     * @param right
     * @return
     */
    private static int partition(int[] array, int left, int right) {
        int prev = left ;
        int cur = left+1;
        while (cur <= right) {
            if(array[cur] < array[left] && array[++prev] != array[cur]) {
                swap(array,cur,prev);
            }
            cur++;
        }

        swap(array,prev,left);
        return prev;
    }

//快速排序（不用递归）
public static void quickSortNor(int[] array) {
    int start = 0;
    int end = array.length - 1;
    Stack<Integer> stack = new Stack<>();
    int pivot = partition(array,start,end);
    if(pivot > start+1) {
        stack.push(start);
        stack.push(pivot-1);
    }
    if (pivot+1 < end) {
        stack.push(pivot+1);
        stack.push(end);
    }
    while (!stack.isEmpty()) {
        end = stack.pop();
        start = stack.pop();
        pivot = partitionHoare(array,start,end);
        if (pivot > start+1) {
            stack.push(start);
            stack.push(pivot-1);
        }
        if (pivot+1 < end) {
            stack.push(pivot+1);
            stack.push(end);
        }
    }
}

【快速排序总结】：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)

在这里插入图片描述

  1. 空间复杂度：O(logN)
  2. 稳定性：不稳定

归并排序

基本思想

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

在这里插入图片描述

在这里插入图片描述

/**
 * 归并排序：
 * 时间复杂度：O(N*logN)
 * 空间复杂度：O(logN)
 * 稳定性：稳定的排序
 * 目前为止3个稳定的排序：直接插入排序、冒泡排序、归并排序
 * @param array
 */
public static void mergeSort(int[] array) {
    mergeSortFun(array,0,array.length-1);
}

private static void mergeSortFun(int[] array,int start,int end) {
    if (start >= end) {
        return;
    }
    int mid = (start+end) / 2;
    //左边
    mergeSortFun(array,start,mid);
    //右边
    mergeSortFun(array,mid+1,end);
    //合并
    merge(array,start,mid,end);
}

private static void merge(int[] array, int left, int mid, int right) {
    int s1 = left;//可以不定义，这样写为了好理解
    int e1 = mid;//可以不定义，这样写为了好理解
    int s2 = mid + 1;
    int e2 = right;//可以不定义，这样写为了好理解
    //定义一个新的数组
    int[] tmpArr = new int[right-left+1];
    int k = 0;//tmpArr数组的下标
    //同时满足 证明两个归并段 都有数据
    while (s1 <= e1 && s2 <= e2) {
        if (array[s1] <= array[s2]) {
            tmpArr[k++] = array[s1++];
        }else {
            tmpArr[k++] = array[s2++];
        }
    }
    while (s1 <= e1) {
        tmpArr[k++] = array[s1++];
    }
    while (s2 <= e2) {
        tmpArr[k++] = array[s2++];
    }
    //把排好序的数据 拷贝回原来的数组array当中
    for (int i = 0; i < tmpArr.length; i++) {
        array[i+left] = tmpArr[i];
    }
}

/**
 * 非递归实现归并排序
 * @param array
 */
public static void mergeSortNor(int[] array) {
    int gap = 1; //每组几个数据
    while (gap < array.length) {
        for (int i = 0;i < array.length;i = i+gap*2) {
            int left = i;
            int mid = left+gap-1; //可能会越界

            int right = mid + gap; //可能会越界

            //解决越界问题
            if(mid >= array.length) {
                mid = array.length-1;
            }
            if(right >= array.length) {
                right = array.length-1;
            }

            merge(array,left,mid,right);
        }
        gap*=2;
    }
}

【归并排序总结】

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序

前提：内存只有 1G，需要排序的数据有 100G

因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

  1. 先把文件切分成 200 份，每个 512 M
  2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
  3. 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

排序算法复杂度及稳定性分析

在这里插入图片描述

在这里插入图片描述

其他非基于比较排序（了解）

计数排序

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中
  1. 申请一个数组
  2. 遍历原来的数组 ，把数字对象的count数组的下标内容 进行++
  3. 遍历计数数组count，写回到原来数组array，只不过此时需要注意：写的次数和元素值要一样，最后数组array当中就会存储有序的序列

在这里插入图片描述

/**
 * 计数排序的场景：
 * 指定范围内的数据
 * 时间复杂度： O(MAX(N,范围))
 * 空间复杂度：O(范围)
 * 稳定性：稳定的排序
 * @param array
 */
public static void countSort(int[] array) {
    int minVal = array[0];
    int maxVal = array[0];
    for (int i = 0;i < array.length;i++) {
        if (array[i] < minVal) {
            minVal = array[i];
        }
        if(array[i] > maxVal) {
            maxVal = array[i];
        }
    }
    //确定计数数组的 长度
    int len = maxVal - minVal + 1;
    int[] count = new int[len];

    //遍历array数组 把数据出现的次数存储到计数数组当中   O(N)
    for (int i = 0; i < array.length; i++) {
        count[array[i]-minVal]++;
    }
    //计数数组已经存放了每个数据出现的次数
    //遍历计数数组 把实际的数据写回array数组  O(范围)
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i] > 0) {
            //这里需要重写写回array 意味着得从array的0位置开始写
            array[index] = i + minVal;
            index++;
            count[i]--;
        }
    }
}

【计数排序的特性总结】

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限
  2. 时间复杂度：O(MAX(N,范围))
  3. 空间复杂度：O(范围)
  4. 稳定性：稳定

基数排序

桶排序

选择题

  1. 快速排序算法是基于( )的一个排序算法。

    A：分治法

    B：贪心法

    C：递归法

    D：动态规划法

  2. 对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入 位置需比较( )次？（采用从后往前比较）

    A: 3

    B: 4

    C: 5

    D: 6

  3. 以下排序方式中占用O(n)辅助存储空间的是( )

    A: 简单排序

    B: 快速排序

    C: 堆排序

    D: 归并排序

  4. 下列排序算法中稳定且时间复杂度为O(n^2)的是( )

    A: 快速排序

    B: 冒泡排序

    C: 直接选择排序

    D: 归并排序

  5. 关于排序，下面说法不正确的是( )

    A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)

    B: 归并排序是一种稳定的排序,堆排序和快排均不稳定

    C: 序列基本有序时，快排退化成 “冒泡排序”，直接插入排序最快

    D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)

  6. 设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（ ）

    A: 34，56，25，65，86，99，72，66

    B: 25，34，56，65，99，86，72，66

    C: 34，56，25，65，66，99，86，72

    D: 34，56，25，65，99，86，72，66

【参考答案】

  1. A 2. C 3. D 4. B 5. D 6. A
阅读全部

相关推荐

  1. <span style='color:red;'>排序</span>

    排序

    2024-06-13 07:00:03      24 阅读

  4. 排序算法——冒泡排序

    2024-06-13 07:00:03       62 阅读

  5. 排序算法——快速排序

    2024-06-13 07:00:03       58 阅读

  10. 排序算法——归并排序

    2024-06-13 07:00:03       61 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-06-13 07:00:03       94 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-06-13 07:00:03       101 阅读

  9. 在Django里面运行非项目文件

    2024-06-13 07:00:03       82 阅读

  19. Python语言-面向对象

    2024-06-13 07:00:03       91 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-06-13 07:00:03       85 阅读

热门阅读

  3. c++【入门】小明买水果

    2024-06-13 07:00:03       24 阅读

  5. Hugging Face Hub 使用DuckDB进行分析

    2024-06-13 07:00:03       37 阅读

  6. TrinityCore启动报错： MySQL library version (8.0.37 id 80037) does not match

    2024-06-13 07:00:03       23 阅读

  7. mysql的双机热备

    2024-06-13 07:00:03       34 阅读

  11. Redis 分布式锁过期了，还没处理完怎么办？

    2024-06-13 07:00:03       28 阅读

  13. 远程工具向日葵的安装

    2024-06-13 07:00:03       24 阅读

  17. python scrapy爬虫学习

    2024-06-13 07:00:03       28 阅读

  18. Web网页前端教程免费：引领您踏入编程的奇幻世界

    2024-06-13 07:00:03       26 阅读

  19. Web前端专科实习：技能提升、实践挑战与职业展望

    2024-06-13 07:00:03       33 阅读

  24. Conda应用

    2024-06-13 07:00:03       18 阅读

  25. day32贪心算法part02| 122.买卖股票的最佳时机II 55. 跳跃游戏 45.跳跃游戏II

    2024-06-13 07:00:03       29 阅读

  26. Python学习笔记11 -- 细碎内容

    2024-06-13 07:00:03       24 阅读