• 数据结构-排序

    目录

    排序的概念及引用

    概念

    稳定性

    运用

    常见排序算法

    常见排序算法的实现

    插入排序

    直接插入排序

    希尔排序

    选择排序

    直接选择排序

    堆排序

    交换排序

    冒泡排序

    快速排序

    Hoare版​

    挖坑法​

    快速排序优化

    快速排序非递归

    归并排序

    非递归实现归并排序

    排序的概念及引用

    概念

    稳定性

    一个稳定的排序可以实现为不稳定的排序，但是一个本身就不稳定的排序无法实现为稳定的排序。

    运用

    常见排序算法

    常见排序算法的实现

    插入排序

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

    直接插入排序

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

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

    1. 元素集合越接近有序，直接插入排序算法的时间效率越高

    2. 时间复杂度：O(N^2)

    3. 空间复杂度：O(1)，它是一种稳定的排序算法

    4. 稳定性：稳定

    希尔排序

     希尔排序可以理解为是插入排序的一种优化。核心逻辑是缩小增量。

    “跳跃式”的分组能够把后边相对小的数据放到前边，能够把前边相对大的数据放到后边。

    gap不为1的情况下都属于预排序。

    希尔排序的特性总结：

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

    2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很

    快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

    3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排 序的时间复杂度都不固定                         4、稳定性：不稳定
    《数据结构(C语言版)》--- 严蔚敏

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

    因为咱们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：来计算。

    1.     /**
    2.      * 稳定性：不稳定的
    3.      * 时间复杂度：logN *
    4.      * @param array
    5.      */
    6.     public static void shellSort(int[] array) {
    7.         int gap = array.length;//n
    8.         while (gap > 1) {
    9.             gap = gap/3 + 1;
    10.             shell(array,gap);
    11.         }
    12.     }
    13.  
    14.     /**
    15.      * 每组进行插入排序
    16.      * @param array
    17.      * @param gap
    18.      */
    19.     private static void shell(int[] array,int gap) {
    20.         //i++ 交替进行插入排序
    21.         for (int i = gap; i < array.length; i++) {
    22.             int tmp = array[i];
    23.             int j = i-gap;
    24.             for (; j >= 0 ; j -= gap) {
    25.                 if(array[j] > tmp) {
    26.                     array[j+gap] = array[j];
    27.                 }else {
    28.                     break;
    29.                 }
    30.             }
    31.             array[j+gap] = tmp;
    32.         }
    33.     }

    选择排序

    直接选择排序

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

    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.      * 时间复杂度：
    9.      *   和数据是否有序无关。均是O(N^2)
    10.      * 空间复杂度： O(1)
    11.      * 稳定性：不稳定的排序
    12.      * @param array
    13.      */
    14.     public static void selectSort1(int[] array) {
    15.         for (int i = 0; i < array.length; i++) {
    16.             int minIndex = i;
    17.             for (int j = i+1; j < array.length; j++) {
    18.                 if(array[j] < array[minIndex]) {
    19.                     minIndex = j;
    20.                 }
    21.             }
    22.             swap(array,minIndex,i);
    23.         }
    24.     }

    另一种选择排序：找到最小值和最大值

    1. public static void selectSort(int[] array) {
    2.         int left = 0;
    3.         int right = array.length-1;
    4.         while (left < right) {
    5.             int minIndex = left;
    6.             int maxIndex = left;
    7.             for (int i = left+1; i <= right; i++) {
    8.                 if(array[i] < array[minIndex]) {
    9.                     minIndex = i;
    10.                 }
    11.                 if(array[i] > array[maxIndex]) {
    12.                     maxIndex = i;
    13.                 }
    14.             }
    15.             swap(array,minIndex,left);
    16.             //如果最大值是 left下标 那么上面交换完成以后，
    17.             // 最大值跑到了最小值的位置，所以得更新最大值下标
    18.             if(maxIndex == left) {
    19.                 maxIndex = minIndex;
    20.             }
    21.             swap(array,maxIndex,right);
    22.             left++;
    23.             right--;
    24.         }
    25.     }

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

    1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

    2. 时间复杂度：O(N^2)

    3. 空间复杂度：O(1)

    4. 稳定性：不稳定

    堆排序

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

    1.     private 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.             //child下标 就是左右孩子最大值的下标
    13.             if(array[child] > array[parent]) {
    14.                 swap(array,child,parent);
    15.                 parent = child;
    16.                 child = 2*parent+1;
    17.             }else {
    18.                 break;
    19.             }
    20.         }
    21.     }
    22.  
    23.     /**
    24.      * 时间复杂度：O(N*logN)
    25.      * 空间复杂度：O(1)
    26.      * 稳定性：不稳定
    27.      * @param array
    28.      */
    29.     public static void heapSort(int[] array) {
    30.         createBigHeap(array);
    31.         int end = array.length-1;
    32.         while (end >= 0) {
    33.             swap(array,0,end);
    34.             siftDown(0,array,end);
    35.             end--;
    36.         }
    37.     }

    交换排序

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

    冒泡排序

    1.     /**
    2.      * 时间复杂度：
    3.      *     不管数据 有序 还是无序 在不优化的情况下：O(N^2) 5 4 3 2 1
    4.      * 空间复杂度：O(1)
    5.      * 稳定性：稳定
    6.      *    目前学到现在为止：2个稳定排序 ，插入排序 冒泡排序
    7.      * @param array
    8.      */
    9.     private static void swap(int[] array,int i,int j) {
    10.         int tmp = array[i];
    11.         array[i] = array[j];
    12.         array[j] = tmp;
    13.     }
    14.     public static void bubbleSort(int[] array) {
    15.         for (int i = 0; i < array.length-1; i++) {
    16.             boolean flg = false;
    17.             for (int j = 0; j < array.length-1-i; j++) {
    18.                 if(array[j] > array[j+1]) {
    19.                     swap(array,j,j+1);
    20.                     flg = true;
    21.                 }
    22.             }
    23.             //在优化了的情况下，当数据有序，1 2 3 4 5
    24.             //时间复杂度为：O(N)
    25.             if(!flg) {
    26.                 break;
    27.             }
    28.         }
    29.     }

    【冒泡排序的特性总结】

    1. 冒泡排序是一种非常容易理解的排序

    2. 时间复杂度：O(N^2)

    3. 空间复杂度：O(1)

    4. 稳定性：稳定

    快速排序

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

    Hoare版
    1.     /**
    2.      * 时间复杂度：O(N*logN)
    3.      * 空间复杂度：O(logN)
    4.      * 稳定性：不稳定
    5.      * @param array
    6.      */
    7.     private static void swap(int[] array,int i,int j) {
    8.         int tmp = array[i];
    9.         array[i] = array[j];
    10.         array[j] = tmp;
    11.     }
    12.     public static void quickSort(int[] array) {
    13.         quick(array,0,array.length-1);
    14.     }
    15.     private static void quick(int[] array,int start,int end) {
    16.         if(start >= end) {
    17.             return;
    18.         }
    19.         int par = partition(array,start,end);
    20.         quick(array,start,par-1);
    21.         quick(array,par+1,end);
    22.     }
    23.     /**
    24.      * Hoare法
    25.      * @param array
    26.      * @param left
    27.      * @param right
    28.      * @return
    29.      */
    30.     private static int partitionHoare(int[] array,int left,int right) {
    31.         int i = left;
    32.         int tmp = array[left];
    33.         while (left < right) {
    34.             //array[right] >= tmp  这里能不能 不取等于号
    35.             // right--; 为什么先走右边
    36.             while (left < right && array[right] >= tmp) {
    37.                 right--;
    38.             }
    39.             while (left < right &&  array[left] <= tmp) {
    40.                 left++;
    41.             }
    42.             swap(array,left,right);
    43.         }
    44.         //left 和 right 相遇了
    45.         swap(array,left,i);
    46.         return left;
    47.     }
    挖坑法
    1. private static int partition(int[] array,int left,int right) {
    2.         int tmp = array[left];
    3.         while (left < right) {
    4.             while (left < right && array[right] >= tmp) {
    5.                 right--;
    6.             }
    7.             array[left] = array[right];
    8.  
    9.             while (left < right && array[left] <= tmp) {
    10.                 left++;
    11.             }
    12.             array[right] = array[left];
    13.         }
    14.         array[left] = tmp;
    15.         return left;
    16.     }
    快速排序优化
    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.     public static void quickSort(int[] array) {
    7.         quick(array,0,array.length-1);
    8.     }
    9.     private static void quick(int[] array,int start,int end) {
    10.         if(start >= end) {
    11.             return;
    12.         }
    13.  
    14.         if(end - start + 1 <= 10) {
    15.             insertSortRange(array,start,end);
    16.             return;
    17.         }
    18.  
    19.         //System.out.println("start: "+start);
    20.         //System.out.println("end: "+end);
    21.         //1 2 3 4 5 6
    22.         //三数取中
    23.         int index = midThreeNum(array,start,end);
    24.         swap(array,index,start);
    25.  
    26.         //3 2 1 4 5
    27.         int par = partition(array,start,end);
    28.  
    29.         quick(array,start,par-1);
    30.         quick(array,par+1,end);
    31.     }
    32.     public static void insertSortRange(int[] array,int left,int right) {
    33.         for (int i = left+1; i <= right; i++) {
    34.             int tmp = array[i];
    35.             int j = i-1;
    36.             for (; j >= left ; j--) {
    37.                 if(array[j] > tmp) {
    38.                     array[j+1] = array[j];
    39.                 }else {
    40.                     break;
    41.                 }
    42.             }
    43.             array[j+1] = tmp;
    44.         }
    45.     }
    46.     //返回值是中位数的下标
    47.     private static int midThreeNum(int[] array,int left,int right) {
    48.         int mid = (left+right)/2;
    49.         if(array[left] < array[right]) {
    50.             if(array[mid] 
    51.                 return left;
    52.             }else if(array[mid] > array[right]) {
    53.                 return right;
    54.             }else {
    55.                 return mid;
    56.             }
    57.         }else {
    58.             if(array[mid] < array[right]) {
    59.                 return right;
    60.             }else if(array[mid] > array[left]) {
    61.                 return left;
    62.             }else {
    63.                 return mid;
    64.             }
    65.         }
    66.     }
    67.     private static int partition(int[] array,int left,int right) {
    68.         int tmp = array[left];
    69.         while (left < right) {
    70.             while (left < right && array[right] >= tmp) {
    71.                 right--;
    72.             }
    73.             array[left] = array[right];
    74.  
    75.             while (left < right && array[left] <= tmp) {
    76.                 left++;
    77.             }
    78.             array[right] = array[left];
    79.         }
    80.         array[left] = tmp;
    81.         return left;
    82.     }
    快速排序非递归
    1.        private static int partition(int[] array,int left,int right) {
    2.         int tmp = array[left];
    3.         while (left < right) {
    4.             while (left < right && array[right] >= tmp) {
    5.                 right--;
    6.             }
    7.             array[left] = array[right];
    8.  
    9.             while (left < right && array[left] <= tmp) {
    10.                 left++;
    11.             }
    12.             array[right] = array[left];
    13.         }
    14.         array[left] = tmp;
    15.         return left;
    16.     }
    17.         public static void quickSortNor(int[] array) {
    18.         Stack stack = new Stack<>();
    19.         int left = 0;
    20.         int right = array.length-1;
    21.         int par = partition(array,left,right);
    22.         if(par > left + 1) {
    23.             stack.push(left);
    24.             stack.push(par-1);
    25.         }
    26.         if(par < right - 1) {
    27.             stack.push(par+1);
    28.             stack.push(right);
    29.         }
    30.         while (!stack.isEmpty()) {
    31.             right = stack.pop();
    32.             left = stack.pop();
    33.             par = partition(array,left,right);
    34.             if(par > left + 1) {
    35.                 stack.push(left);
    36.                 stack.push(par-1);
    37.             }
    38.             if(par < right - 1) {
    39.                 stack.push(par+1);
    40.                 stack.push(right);
    41.             }
    42.         }
    43.     }

    【快速排序总结】

    1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

    2. 时间复杂度：O(N*logN)

    3. 空间复杂度：O(logN)

    4. 稳定性：不稳定

    归并排序

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

    1.     /**
    2.      * 时间复杂度：0(N * logN)
    3.      * 空间复杂度：O(N)
    4.      * 稳定性：稳定的排序
    5.      * @param array
    6.      */
    7.     public static void mergeSort(int[] array) {
    8.         mergeSortFun(array,0,array.length-1);
    9.     }
    10.  
    11.     public static void mergeSortFun(int[] array,int left,int right) {
    12.         if(left >= right) {// >
    13.             return;
    14.         }
    15.         int mid = (right+left) / 2;
    16.         mergeSortFun(array,left,mid);
    17.         mergeSortFun(array,mid+1,right);
    18.         //合并
    19.         merge(array,left,mid,right);
    20.     }
    21.     private static void merge(int[] array,int left,
    22.                               int mid,int right) {
    23.         int[] tmp = new int[right-left+1];
    24.         int k = 0;
    25.         int s1 = left;
    26.         int e1 = mid;
    27.         int s2 = mid+1;
    28.         int e2 = right;
    29.         while (s1 <= e1 && s2 <= e2) {
    30.             if(array[s1] <= array[s2]) {
    31.                 tmp[k++] = array[s1++];
    32.             }else {
    33.                 tmp[k++] = array[s2++];
    34.             }
    35.         }
    36.         while (s1 <= e1) {
    37.             tmp[k++] = array[s1++];
    38.         }
    39.         while (s2 <= e2) {
    40.             tmp[k++] = array[s2++];
    41.         }
    42.         //走到这里 相当于tmp数组 当中 所有的元素 都有序了
    43.         //接下来把tmp数组的内容 拷贝到array数组当中
    44.         for (int i = 0; i < k; i++) {
    45.             array[i+left] = tmp[i];
    46.         }
    47.     }
    非递归实现归并排序
    1.     /**
    2.      * 非递归实现归并排序
    3.      * @param array
    4.      */
    5.     public static void mergeSortNor(int[] array) {
    6.         int gap = 1;
    7.         while (gap < array.length) {
    8.             for (int i = 0; i < array.length; i = i + 2*gap) {
    9.                 int left = i;
    10.                 int mid = left+gap - 1;
    11.                 if(mid >= array.length) {
    12.                     mid = array.length-1;
    13.                 }
    14.                 int right = mid+gap;
    15.                 if(right >= array.length) {
    16.                     right = array.length-1;
    17.                 }
    18.                 merge(array,left,mid,right);
    19.             }
    20.             gap *= 2;
    21.         }
    22.     }

    【归并排序总结】

    1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

    2. 时间复杂度：O(N*logN)

    3. 空间复杂度：O(N)

    4. 稳定性：稳定

  • 相关阅读:
    java毕业设计便利店系统mybatis+源码+调试部署+系统+数据库+lw
    一、了解 Servlet 及 Servlet 容器
    基于文件上传漏洞获得网站 shell 权限
    【JVM技术专题】精心准备了一套JVM分析工具的锦囊「JConsole补充篇」
    如何解决网页中的pdf文件无法下载？pdf打印显示空白怎么办？
    地图加载wmts格式底图的配置
    2022年电动车与车辆工程国际会议（CEVVE 2022）
    605. 简单乘积
    副业教程之如何通过出售API赚取美元含数据集和训练教程
    电脑配音配音软件哪个好用？推荐3个好用软件
  • 原文地址：https://blog.csdn.net/2301_80141037/article/details/143089964