• 常见排序算法(插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序，桶排序）

    一.排序的概念

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

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

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

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

    二.常见的排序

    接下来我们将一一讲解上述排序算法的实现

    三.常见排序算法的实现

    1.直接插入排序

    1.1基本思想

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

    1.2实现

    1.     /**
    2.      * 时间复杂度：O(N^2)
    3.      *      最好情况下呢？ 有序的时候  O(n)
    4.      *      结论：对于直接插入排序来说  数据越有序 越快
    5.      * 空间复杂度：O(1)
    6.      * 稳定性：稳定
    7.      *     一个稳定的排序  可以实现为不稳定的排序
    8.      *     但是 一个本身就不稳定的排序  无法实现为稳定的排序
    9.      *
    10.      * 场景：当前有一组数据 基本上趋于有序 那么就可以使用直接插入排序
    11.      * 优点：越有序越快
    12.      * @param array
    13.      */
    15. public static void insertSort(int[] array){
    16.         for (int i = 1; i <array.length; i++) {
    17.             int tmp=array[i];
    18.             int j=i-1;
    19.             for(;j>=0;j--){//将tmp与下标为0到i-1的作比较，若tmp大则将tmp赋给该下标后一位
    20.                 if(array[j]>tmp){
    21.                     array[j+1]=array[j];
    22.                 }else{
    23.                     break;
    24.                 }
    25.             }
    26.             array[j+1]=tmp;
    27.         }
    28.     }

    2希尔排序

    2.1基本思想

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

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

    2.2实现

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

    3选择排序

    3.1基本思想

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

    3.2实现

    1.     private static void swap(int[] array,int i,int j){
    2.         int tmp=array[i];
    3.         array[i]=array[j];
    4.         array[j]=tmp;
    5.     }
    6.  
    7.     /**
    8.      * 时间复杂度: 和数据是否有序无关，均为O(N^2)
    9.      * 空间复杂度:O(1)
    10.      * 稳定性:不稳定的排序
    11.      * @param array
    12.      */
    13.     public static void selectSort1(int[] array){
    14.         for(int i=0;i< array.length;i++){
    15.             int minIndex=i;
    16.             for(int j=i+1;j< array.length;j++){
    17.                 if(array[j]<array[minIndex]){
    18.                     minIndex=j;
    19.                 }
    20.             }
    21.             swap(array,minIndex,i);
    22.         }
    23.     }
    24.  
    25.     public static void selectSort(int[] array){
    26.         int left=0;
    27.         int right=array.length-1;
    28.  
    29.         while(left<right){
    30.             int minIndex=left;
    31.             int maxIndex=left;
    32.             for(int i=left+1;i<=right;i++){
    33.                 if(array[i]<array[minIndex]){
    34.                     minIndex=i;
    35.                 }
    36.                 if(array[i]>array[maxIndex]){
    37.                     maxIndex=i;
    38.                 }
    39.             }
    40.             swap(array,minIndex,left);
    41.             //如果最大值是left下标，那么上面交换完成以后，
    42.             //最大值跑到了最小值的位置，所以要更新最大值下标
    43.             if(maxIndex==left){
    44.                 maxIndex=minIndex;
    45.             }
    46.             swap(array,maxIndex,right);
    47.             left++;
    48.             right--;
    49.         }
    50.     }

    4堆排序

    4.1基本思想

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

    4.2实现

    1.  public static void createBigHeap(int[] array){
    2.         for (int parent=(array.length-1-1/)/2;parent>=0;parent--){
    3.             siftDown(parent,array,array.length);
    4.         }
    5.     }
    6.     private static void siftDown(int parent,int[] array,int end){
    7.         int child=2*parent+1;
    8.         while(child<end){
    9.             if(child+1<end&&array[child]<array[child+1]){
    10.                 child++;
    11.             }
    12.             if(array[child]>array[parent]){
    13.                 swap(array,child,parent);
    14.                 parent=child;
    15.                 child=parent*2+1;
    16.             }else{
    17.                 break;
    18.             }
    19.         }
    20.     }
    21.  
    22.     /**
    23.      * 时间复杂度:O(N*logN)
    24.      * 空间复杂度:O(1)
    25.      * 稳定性:不稳定
    26.      * @param array
    27.      */
    28.     public static void heapSort(int[] array){
    29.         createBigHeap(array);
    30.         int end=array.length-1;
    31.         while(end>=0){
    32.             swap(array,0,end);
    33.             siftDown(0,array,end);
    34.             end--;
    35.         }
    36.     }

    5冒泡排序

    5.1基本思想

    根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置

    5.2实现

    1. /**
    2.      * 时间复杂度:不管数据有序与否，不优化的情况下均为O（N^2）
    3.      * 空间复杂度:1
    4.      * 稳定性:稳定
    5.      *
    6.      * @param array
    7.      */
    8.     public static void bubbleSort(int[] array){
    9.         for(int i=0;i<array.length-1;i++){
    10.             boolean flg=false;
    11.             for(int j=0;j< array.length-i-1;j++){
    12.                 if(array[j]>array[j+1]){
    13.                     swap(array,j,j+1);
    14.                     flg=true;
    15.                 }
    16.             }
    17.             if(!flg){//优化下，当数据有序，时间复杂度为O（N）
    18.                 break;
    19.             }
    20.         }
    21.     }

    6快速排序

    6.1基本思想

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

    6.2实现

    1. public static void quickSort(int[] array) {
    2.                 quick(array, 0, array.length - 1);
    3.             }
    4.  
    5.             private static void quick(int[] array, int start, int end) {
    6.                 if (start >= end) {
    7.                     return;
    8.                 }
    9.  
    10.                 if (end - start + 1 <= 10) {
    11.                     insertSortRange(array, start, end);
    12.                     return;
    13.                 }
    14.  
    15.                 int index = midThreeNum(array, start, end);
    16.                 swap(array, index, start);
    17.  
    18.                 int par = partition(array, start, end);
    19.  
    20.                 quick(array, start, par - 1);
    21.                 quick(array, par + 1, end);
    22.             }
    23.  
    24.             public static void insertSortRange(int[] array, int left, int right) {
    25.                 for (int i = left + 1; i <= right; i++) {
    26.                     int tmp = array[i];
    27.                     int j = i - 1;
    28.                     for (; j >= left; j--) {
    29.                         if (array[j] > tmp) {
    30.                             array[j + 1] = array[j];
    31.                         } else {
    32.                             break;
    33.                         }
    34.                     }
    35.                     array[j + 1] = tmp;
    36.                 }
    37.             }
    38.  
    39.             //返回值是中位数的下标
    40.             private static int midThreeNum(int[] array, int left, int right) {
    41.                 int mid = (left + right) / 2;
    42.                 if (array[left] < array[right]) {
    43.                     if (array[mid] < array[left]) {
    44.                         return left;
    45.                     } else if (array[mid] > array[right]) {
    46.                         return right;
    47.                     } else {
    48.                         return mid;
    49.                     }
    50.                 } else {
    51.                     if (array[mid] < array[right]) {
    52.                         return right;
    53.                     } else if (array[mid] > array[left]) {
    54.                         return left;
    55.                     } else {
    56.                         return mid;
    57.                     }
    58.                 }
    59.             }
    60.  
    61.             private static int partitionHoare(int[] array, int left, int right) {
    62.                 int i = left;
    63.                 int tmp = array[left];
    64.                 while (left < right) {
    65.                     while (left < right && array[right] >= tmp) {
    66.                         right--;
    67.                     }
    68.             while (left < right && array[left] <= tmp) {
    69.                 left++;
    70.             }
    71.             swap(array, left, right);
    72.         }
    73.         swap(array, left, i);
    74.         return left;
    75.     }
    76.  
    77.     private static int partition(int[] array, int left, int right) {
    78.         int tmp = array[left];
    79.         while (left < right) {
    80.             while (left < right && array[right] >= tmp) {
    81.                 right--;
    82.             }
    83.             array[left] = array[right];
    84.             while (left < right && array[left] <= tmp) {
    85.                 left++;
    86.             }
    87.             array[right] = array[left];
    88.         }
    89.         array[left] = tmp;
    90.         return left;
    91.     }
    92.  
    93.     private static int partitionPre(int[] array, int left, int right) {
    94.         int prev = left;
    95.         int cur = left + 1;
    96.         while (cur <= right) {
    97.             if (array[cur] < array[left] && array[++prev] != array[cur]) {
    98.                 swap(array, cur, prev);
    99.             }
    100.             cur++;
    101.         }
    102.         swap(array, prev, left);
    103.         return prev;
    104.     }
    105.  
    106.     public static void quickSortNor(int[] array) {
    107.         Stack<Integer> stack = new Stack<>();
    108.         int left = 0;
    109.         int right = array.length - 1;
    110.         int par = partition(array, left, right);
    111.         if (par > left + 1) {
    112.             stack.push(left);
    113.             stack.push(par - 1);
    114.         }
    115.         if (par < right - 1) {
    116.             stack.push(par + 1);
    117.             stack.push(right);
    118.         }
    119.         while (!stack.isEmpty()) {
    120.             right = stack.pop();
    121.             left = stack.pop();
    122.             par = partition(array, left, right);
    123.             if (par > left + 1) {
    124.                 stack.push(left);
    125.                 stack.push(par - 1);
    126.             }
    127.             if (par < right - 1) {
    128.                 stack.push(par + 1);
    129.                 stack.push(right);
    130.             }
    131.  
    132.         }
    133.     }

    7归并排序

    7.1基本思想

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

    7.2实现

    1.  public static void mergeSort(int[] array) {
    2.         mergeSortFun(array, 0, array.length - 1);
    3.     }
    4.  
    5.     public static void mergeSortFun(int[] array, int left, int right) {
    6.         if (left >= right) {
    7.             return;
    8.         }
    9.         int mid = (right + left) / 2;
    10.         mergeSortFun(array, left, mid);
    11.         mergeSortFun(array, mid + 1, right);
    12.     }
    13.  
    14.     private static void merge(int[] array,int left,int mid,int right){
    15.         int[] tmp=new int[right-left+1];
    16.         int k=0;
    17.         int s1=left;
    18.         int e1=mid;
    19.         int s2=mid+1;
    20.         int e2=right;
    21.         while(s1<=e1&&s2<=e2){
    22.             if(array[s1]<=array[s2]){
    23.                 tmp[k++]=array[s1++];
    24.             }else{
    25.                 tmp[k++]=array[s2++];
    26.             }
    27.         }
    28.         while (s1 <= e1) {
    29.             tmp[k++] = array[s1++];
    30.         }
    31.         while (s2 <= e2) {
    32.             tmp[k++] = array[s2++];
    33.         }
    34.         //走到这里 相当于tmp数组中 所有元素都有序了
    35.         //接下来将tmp数组的内容拷贝到array数组当中
    36.         for(int i=0;i<k;i++){
    37.             array[i+left]=tmp[i];
    38.         }
    39.     }
    40.  
    41.     /**
    42.      * 非递归实现归并排序
    43.      */
    44.     public static void mergeSortNor(int[] array){
    45.         int gap=1;
    46.         while(gap<array.length){
    47.             for(int i=0;i<array.length;i=i+2*gap){
    48.                 int left=i;
    49.                 int mid=left+gap-1;
    50.                 if(mid>=array.length){
    51.                     mid=array.length-1;
    52.                 }
    53.                 int right=mid+gap;
    54.                 if(right>=array.length){
    55.                     right=array.length-1;
    56.                 }
    57.                 merge(array,left,mid,right);
    58.             }
    59.             gap*=2;
    60.         }
    61.     }

    8其他排序（计数排序、基数排序、桶排序）

    8.1计数排序

    计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用

    操作步骤
    1. 统计相同元素出现次数
    2. 根据统计的结果将序列回收到原来的序列中

    1. /**
    2.      * 计数排序
    3.      * 时间复杂度:O(N+范围)
    4.      * 空间复杂度:O(范围)
    5.      * 稳定性:稳定
    6.      */
    7.     public static void countSort(int[] array){
    8.         //1.遍历数组，求最大值与最小值
    9.         int maxVal=array[0];
    10.         int minVal=array[0];
    11.         for(int i=0;i<array.length;i++){
    12.             if(maxVal<array[i]){
    13.                 maxVal=array[i];
    14.             }
    15.             if(minVal>array[i]){
    16.                 minVal=array[i];
    17.             }
    18.         }
    19.         //2.定义count数组
    20.         int[] count=new int[maxVal-minVal+1];
    21.         //3.遍历array数组，把值放入计数数组中
    22.         for(int i=0;i<array.length;i++){
    23.             int val=array[i];
    24.             count[val-minVal]++;
    25.         }
    26.         //4.以上3步完成之后，计数数组已经存好了相应的数据
    27.         //接下来 开始遍历数组 计数数组
    28.         int index=0;
    29.         for(int i=0;i<count.length;i++){
    30.             while(count[i]>0){
    31.                 array[index]=i+minVal;
    32.                 index++;
    33.                 count[i]--;
    34.             }
    35.         }
    36.     }

     

    8.2基数排序

    1.10 基数排序 | 菜鸟教程 (runoob.com)

    8.3桶排序

    1.9 桶排序 | 菜鸟教程 (runoob.com)

    如果上述内容对您有帮助，希望给个三连谢谢！ 

     

  • 相关阅读:
    c语言练习48:总结字符函数和字符串函数
    高压放大器在改良电形成装置参数优化中的应用
    设计模式：迭代器模式
    kafka在linux上集群部署说明
    指针变量和地址
    Mathorcup数学建模竞赛第四届-【妈妈杯】C题：家庭暑期旅游最佳线路套餐设计（附lingo代码）
    微服务3 Eureka注册中心
    CSS盒子模型（上）
    cwnd ＜ 1 时的拥塞控制
    C++学习日记——函数指针
  • 原文地址：https://blog.csdn.net/2301_80288511/article/details/137935078