• 【数据结构】——排序

    目录

    一、排序的概念

     二、常见排序算法的实现

    2.1 插入排序

    2.1.1 直接插入排序 

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

    2.2 选择排序

    2.2.1 基本思想

    2.2.2 直接选择排序

    2.2.3 堆排序

    2.3 交换排序

    2.3.1 冒泡排序

    2.3.2 快速排序

    2.3.3 快速排序的的优化

    2.3.4 快排的非递归实现（通过栈实现）

    2.4 归并排序

    一、排序的概念

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

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

    常见的排序算法:

     二、常见排序算法的实现

    2.1 插入排序

    2.1.1 直接插入排序 

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

    1.     /**总结:
    2.      * 直接插入排序
    3.      * 时间复杂度:
    4.      *        最坏情况(逆序): O(n^2)
    5.      *        最好情况(有序)：O(n)
    6.      *        结论：对于插入排序来说，数据越有序越快
    7.      *        场景：当数据基本上是有序的时候，使用直接插入排序
    8.      * 空间复杂度:O(1)
    9.      * 稳定性：稳定
    10.      * @param array
    11.      */
    12.     public void insertSort(int[] array){
    13.         int j = 0;
    14.         for (int i = 1; i < array.length; i++) {
    15.             int tmp = array[i];
    16.             for (j = i-1; j >= 0; j--) {
    17.                 if (array[j] > tmp){
    18.                     array[j+1] = array[j];
    19.                 }else {
    20.                     break;
    21.                 }
    22.             }
    23.             array[j+1] = tmp;
    24.         }
    25.     }

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

    1. 先分组
    2. 然后组内直接插入排序

    1. /**
    2.      * 时间复杂度:O(N^1.3 ~ N^1.5)
    3.      * 空间复杂度:O(1)
    4.      * 稳定性:不稳定
    5.      * @param array
    6.      * @param gap
    7.      */
    8.     private static void shell(int[] array,int gap){
    9.         int j = 0;
    10.         for (int i = gap; i < array.length; i++) {
    11.             int tmp = array[i];
    12.             for (j = i-gap; j >= 0; j-=gap) {
    13.                 if (array[j] > tmp){
    14.                     array[j+gap] = array[j];
    15.                 }else {
    16.                     break;
    17.                 }
    18.             }
    19.             array[j+gap] = tmp;
    20.         }
    21.     }
    22.     public static void shellSort(int[] array){
    23.         int gap = array.length;
    24.         while (gap > 1){
    25.             shell(array,gap);
    26.             gap/=2;
    27.         }
    28.         shell(array,1);
    29.     }

     希尔排序的特性总结:

    1. 希尔排序是对直接插入排序的优化
    2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比
    3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定

    2.2 选择排序

    2.2.1 基本思想

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

    2.2.2 直接选择排序

    1. 在元素集合array[i] ~ array[n-1]中选择关键码最大(小)的数据元素
    2. 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个元素交换
    3. 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
    1.     /**
    2.      * 时间复杂度:O(N^2) ->对数据不敏感
    3.      * 空间复杂度:O(1)
    4.      * 稳定性:不稳定
    5.      * @param array
    6.      */
    7.     public static void selectSort(int[] array){
    8.         for (int i = 0; i < array.length; i++) {
    9.             //每次吧minIndex的值当做最小值
    10.             int minIndex = i;
    11.             for (int j = i+1; j < array.length; j++) {
    12.                 if (array[j] < array[minIndex]){
    13.                     minIndex = j;
    14.                 }
    15.             }
    16.             swap(array,minIndex,i);
    17.         }
    18.     }
    19.     private static void swap(int[] array,int i,int j){
    20.         int tmp = array[i];
    21.         array[i] = array[j];
    22.         array[j] = tmp;
    23.     }

    当我们一次性选择两个时:

    1.     /**
    2.      * 时间复杂度:O(N^2) ->对数据不敏感
    3.      * @param array
    4.      */
    5.     public static void selectSort2(int[] array){
    6.         int left = 0;
    7.         int right = array.length-1;
    8.         while (left < right){
    9.             int minIndex = left;
    10.             int maxIndex = left;
    11.             for (int i = left+1; i <= right; i++) {
    12.                 if (array[i] < array[minIndex]){
    13.                     minIndex = i;
    14.                 }
    15.                 if (array[i] > array[maxIndex]){
    16.                     maxIndex = i;
    17.                 }
    18.             }
    19.             swap(array,left,minIndex);
    20.             //修正maxIndex下标
    21.             if (maxIndex == left){
    22.                 maxIndex = minIndex;
    23.             }
    24.             swap(array,right,maxIndex);
    25.             left++;
    26.             right--;
    27.         }
    28.     }

    2.2.3 堆排序

    一般升序建立大根堆,降序建立小根堆:

     

    1. /**
    2.      * 时间复杂度:O(N*log2 N) ->对数据不敏感
    3.      * 空间复杂度:O(1)
    4.      * 稳定性:不稳定
    5.      * @param array
    6.      */
    7.     public  static void heapSort(int[] array){
    8.         createBigHeap(array);
    9.         int end = array.length-1;
    10.         while (end >= 0){
    11.             swap(array,0,end);
    12.             shiftDown(array,0,end);
    13.             end--;
    14.         }
    15.     }
    16.     private static void createBigHeap(int[] array){
    17.         for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
    18.             shiftDown(array,parent, array.length);
    19.         }
    20.     }
    21.     private static void shiftDown(int[] array,int parent,int len){
    22.         int child = 2*parent+1;
    23.         //最起码保证有左孩子
    24.         while (child < len){
    25.             if (child+1 < len && array[child] < array[child+1]){
    26.                 //保存大的下标
    27.                 child++;
    28.             }
    29.             if (array[child] > array[parent]){
    30.                 swap(array,child,parent);
    31.                 parent = child;
    32.                 child = 2*parent+1;
    33.             }else {
    34.                 break;
    35.             }
    36.         }
    37.     }

    2.3 交换排序

    基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，

    交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

    2.3.1 冒泡排序

    1.     /**
    2.      * 时间复杂度:O(N^2) ->对数据不敏感
    3.      *         优化后时间复杂度为:O(n)
    4.      * 空间复杂度:O(1)
    5.      * 稳定性:稳定
    6.      * @param array
    7.      */
    8.     public static void bubbleSort(int[] array){
    9.         for (int i = 0; i < array.length-1; i++) {
    10.             boolean flag = false;
    11.             for (int j = 0; j < array.length-1-i; j++) {
    12.                 if (array[j] > array[j+1]){
    13.                     swap(array,j,j+1);
    14.                     flag = true;
    15.                 }
    16.             }
    17.             if (!flag){
    18.                 break;
    19.             }
    20.         }
    21.     }

    2.3.2 快速排序

    快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：

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

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

    1、Hoare版

    1.     /**
    2.      * 时间复杂度:O(N * log2 N) -> [理想状态下:数据无序]
    3.      *         O(n^2) -> [最差情况下:数据有序或者逆序]
    4.      * 空间复杂度:O(1)
    5.      * 稳定性:不稳定
    6.      * @param array
    7.      * @param start
    8.      * @param end
    9.      * @return
    10.      */
    11.     private static int partition(int[] array,int start,int end){
    12.         int key = array[start];
    13.         int i = start;
    14.         while (start < end){
    15.             while (start < end && array[end] >= key){
    16.                 end--;
    17.             }
    18.             while (start < end && array[start] <= key){
    19.                 start++;
    20.             }
    21.             swap(array,start,end);
    22.         }
    23.         swap(array,start,i);
    24.         return start;
    25.     }
    26.     private static void quick(int[] array,int left,int right) {
    27.         if (left >= right) {
    28.             return;
    29.         }
    30.         int pivot = partition(array, left, right);
    31.         quick(array, left, pivot - 1);
    32.         quick(array, pivot + 1, right);
    33.  
    34.     }
    35.     public static void quickSort1(int[] array){
    36.         quick(array,0, array.length-1);
    37.     }
    38.

     2、挖坑法

    1. /**
    2.      * 时间复杂度:O(N * log2 N) -> [理想状态下:数据无序]
    3.      *         O(n^2) -> [最差情况下:数据有序或者逆序]
    4.      * 空间复杂度:O(1)
    5.      * 稳定性:不稳定
    6.      * @param array
    7.      * @param start
    8.      * @param end
    9.      * @return
    10.      */
    11.     private static int partition(int[] array,int start,int end){
    12.         int key = array[start];
    13.         int i = start;
    14.         while (start < end){
    15.             while (start < end && array[end] >= key){
    16.                 end--;
    17.             }
    18.             array[start] = array[end];
    19.             while (start < end && array[start] <= key){
    20.                 start++;
    21.             }
    22.             array[end] = array[start];
    23.         }
    24.         array[start] = key;
    25.         return start;
    26.     }
    27.     private static void quick(int[] array,int left,int right) {
    28.         if (left >= right) {
    29.             return;
    30.         }
    31.         int pivot = partition(array, left, right);
    32.         quick(array, left, pivot - 1);
    33.         quick(array, pivot + 1, right);
    34.  
    35.     }
    36.     public static void quickSort1(int[] array){
    37.         quick(array,0, array.length-1);
    38.     }

    3、前后指针法

    1. /**
    2.      * 时间复杂度:O(N * log2 N) -> [理想状态下:数据无序]
    3.      *         O(n^2) -> [最差情况下:数据有序或者逆序]
    4.      * 空间复杂度:O(1)
    5.      * 稳定性:不稳定
    6.      * @param array
    7.      * @param start
    8.      * @param end
    9.      * @return
    10.      */
    11.     private static int partition(int[] array,int start,int end){
    12.         int prev = start;
    13.         int cur = start + 1;
    14.         while (cur <= end){
    15.             if (array[cur] < array[start] && array[++prev] != array[cur]){
    16.                 swap(array,cur,prev);
    17.             }
    18.             cur++;
    19.         }
    20.         swap(array,prev,start);
    21.         return prev;
    22.     }
    23.     private static void quick(int[] array,int left,int right) {
    24.         if (left >= right) {
    25.             return;
    26.         }
    27.         int pivot = partition(array, left, right);
    28.         quick(array, left, pivot - 1);
    29.         quick(array, pivot + 1, right);
    30.  
    31.     }
    32.     public static void quickSort1(int[] array){
    33.         quick(array,0, array.length-1);
    34.     }

    2.3.3 快速排序的的优化

    当数据有序的时候，时间复杂度就为O(N^2)，为了解决这个问题我们便有了一下的优化：

    1、三数取中法选取key

    1.     /**
    2.      * 三数取中
    3.      * @param array
    4.      * @param left
    5.      * @param right
    6.      * @return
    7.      */
    8.     private static int midNumIndex(int[] array,int left,int right){
    9.         int mid = (left+right)/2;
    10.         if (array[left] < array[right]){
    11.             if (array[mid] < array[left]){
    12.                 return left;
    13.             }else if (array[mid] > array[right]){
    14.                 return right;
    15.             }else {
    16.                 return mid;
    17.             }
    18.         }else {
    19.             if (array[mid] < array[right]){
    20.                 return right;
    21.             }else if (array[mid] > array[left]){
    22.                 return left;
    23.             }else {
    24.                 return mid;
    25.             }
    26.         }
    27.     }

    2.、递归到小的子区间时，可以考虑使用插入排序：

    1. public static void insertSort2(int[] array,int start,int end){
    2.         int j = 0;
    3.         for (int i = start+1; i <= end; i++) {
    4.             int tmp = array[i];
    5.             for (j = i-1; j >= start; j--) {
    6.                 if (array[j] > tmp){
    7.                     array[j+1] = array[j];
    8.                 }else {
    9.                     break;
    10.                 }
    11.             }
    12.             array[j+1] = tmp;
    13.         }
    14.     }
    15.     private static void quick(int[] array,int left,int right) {
    16.         if (left >= right) {
    17.             return;
    18.         }
    19.         if (right - left <= 15){
    20.             insertSort2(array,left,right);
    21.             return;
    22.         }
    23.         int index = midNumIndex(array,left,right);
    24.         swap(array,left,index);
    25.         int pivot = partition(array, left, right);
    26.         quick(array, left, pivot - 1);
    27.         quick(array, pivot + 1, right);
    28.  
    29.     }

    2.3.4 快排的非递归实现（通过栈实现）

    1. public static void quickSort(int[] array){
    2.         Stack stack = new Stack<>();
    3.         int left = 0;
    4.         int right = array.length-1;
    5.         int pivot = partition1(array,left,right);
    6.         if (pivot > left+1) {
    7.             stack.push(left);
    8.             stack.push(pivot - 1);
    9.         }
    10.         if (pivot < right-1) {
    11.             stack.push(pivot + 1);
    12.             stack.push(right);
    13.         }
    14.         while (!stack.empty()){
    15.             right = stack.pop();
    16.             left = stack.pop();
    17.             pivot = partition1(array,left,right);
    18.             if (pivot > left+1) {
    19.                 stack.push(left);
    20.                 stack.push(pivot - 1);
    21.             }
    22.             if (pivot < right-1) {
    23.                 stack.push(pivot + 1);
    24.                 stack.push(right);
    25.             }
    26.         }
    27.     }

    2.4 归并排序

    1.     /**
    2.      * 时间复杂度:O(n*log n)
    3.      * 空间复杂度:O(n)
    4.      * 稳定性:稳定
    5.      * @param array
    6.      * @param left
    7.      * @param right
    8.      */
    9.     private static void mergeSortFunc(int[] array,int left, int right){
    10.         if (left >= right){
    11.             return;
    12.         }
    13.         int mid = (left + right)/2;
    14.         //1.分解左边
    15.         mergeSortFunc(array,left,mid);
    16.         //2.分解右边
    17.         mergeSortFunc(array,mid+1,right);
    18.         //3.进行合并
    19.         merge(array,left,right,mid);
    20.     }
    21.     private static void merge(int[] array,int start,int end,int midIndex){
    22.         int[] tmpArray = new int[end-start+1];
    23.         int k = 0;
    24.         int s1 = start;
    25.         int s2 = midIndex+1;
    26.         //两个归并段都有数据
    27.         while (s1 <= midIndex && s2 <= end){
    28.             if (array[s1] < array[s2]){
    29.                 tmpArray[k++] = array[s1++];
    30.             }else {
    31.                 tmpArray[k++] = array[s2++];
    32.             }
    33.         }
    34.         //当做到这里的时候  说明拷贝的数据
    35.         while (s1 <= midIndex){
    36.             tmpArray[k++] = array[s1++];
    37.         }
    38.         while (s2 <= end){
    39.             tmpArray[k++] = array[s2++];
    40.         }
    41.         //把排序好的数据 拷贝到原数组
    42.         for (int i = 0; i < k; i++) {
    43.             array[i+start] = tmpArray[i];
    44.         }
    45.     }
    46.     public static void mergeSort(int[] array){
    47.         mergeSortFunc(array,0, array.length-1);
    48.     }

    归并排序的非递归实现:

    1. public static void mergeSort(int[] array){
    2.         int gap = 1;
    3.  
    4.         while (gap < array.length){
    5.             for (int i = 0; i < array.length; i+=gap*2) {
    6.                 int s1 = i;
    7.                 int e1 = s1+gap-1;
    8.                 if (e1 >= array.length){
    9.                     e1 = array.length-1;
    10.                 }
    11.  
    12.                 int e2 = e1+gap;
    13.                 if (e2 >= array.length){
    14.                     e2 = array.length-1;
    15.                 }
    16.                 merge(array,s1,e2,e1);
    17.             }
    18.             gap *= 2;
    19.         }
    20.     }

    总结:

     

  • 相关阅读:
    STM32数据类型重定义说明
    乘法逆元做法——约数之和
    WebPack5进阶使用总结(二)
    进程和线程概念和区别详解
    [python] 离线安装包-实践记录
    在pandas中使用query替代loc进行高效简洁的条件筛选
    C语言实现“队列“
    Vue框架的原生UI组件Kendo UI for Vue——主题 & 样式概述
    Amazonlinux2023(AL2023)获取metadata
    【一天一个设计模式】—— 抽象工厂模式
  • 原文地址：https://blog.csdn.net/weixin_62678196/article/details/126701755