devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

七大排序算法—图文详解（插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序）_7大排序算法

作者：天景科技苑 | 2024-08-12 06:55:47

赞

踩

7大排序算法

ced485cbb11e458d81a746890b32cf3f.gif 

作者：渴望力量的土狗

博客主页：渴望力量的土狗的博客主页

专栏：数据结构与算法

工欲善其事必先利其器，给大家介绍一款超牛的斩获大厂offer利器——牛客网

点击免费注册和我一起刷题吧

目录

插入排序：

基本思想： 

直接插入排序：

 希尔排序：

基本思想：

选择排序： 

基本思想： 

直接选择排序:

堆排序

交换排序 

 基本思想：

冒泡排序： 

快速排序： 

基本思想： 

归并排序 

基本思想：

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

插入排序：

插入排序过程

基本思想： 

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

直接插入排序：

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

插入排序

 代码实现：

  1.     //插入排序：
  2.     public void insertSort(int[]arr){
  3.  
  4.         for (int i = 1; i < arr.length ; i++) {
  5.             int j=i-1;
  6.             int tmp=arr[i];
  7.             while(j>=0){
  8.  
  9.                 if(arr[j]>tmp){
  10.                     arr[j+1]=arr[j];
  11.                 }
  12.                 if(arr[j]<tmp){
  13.                     arr[j+1]=tmp;
  14.                     break;
  15.                 }
  16.                 j--;
  17.             }
  18.             arr[j+1]=tmp;
  19.         }
  20.     }

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

 希尔排序：

 图片来源于网络

基本思想：

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


 

 代码实现：

  1.     public void shellSort(int[]arr){
  2.  
  3.         int gap= arr.length/2;
  4.  
  5.         while(gap>=1){
  6.  
  7.             for(int i=gap;i<arr.length;i++){
  8.                 int j=i-gap;
  9.                 int tmp=arr[i];
  10.                 while(j>=0){
  11.  
  12.                     if(arr[j]>tmp){
  13.                         arr[j+gap]=arr[j];
  14.                     }
  15.                     if(arr[j]<tmp){
  16.                         arr[j+gap]=tmp;
  17.                         break;
  18.                     }
  19.                     j-=gap;
  20.                 }
  21.                 arr[j+gap]=tmp;
  22.  
  23.             }
  24.             gap/=2;
  25.         }
  26.     }

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

4. 稳定性：不稳定

选择排序： 

选择排序过程

基本思想： 

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

直接选择排序:

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

选择排序

代码实现：

  1.     public void selectSort(int[]arr){
  2.  
  3.         for(int i=0;i< arr.length;i++){
  4.             int minIndex=i;
  5.  
  6.             int j=i+1;
  7.             while(j< arr.length){
  8.  
  9.                 if(arr[j]<arr[minIndex]){
  10.                     minIndex=j;
  11.                 }
  12.  
  13.                 j++;
  14.             }
  15.             if(minIndex!=i){
  16.                 swap(arr,i,minIndex);
  17.             }
  18.  
  19.         }
  20.  
  21.     }
  22.     public void swap(int[]arr,int i,int j){
  23.         int temp=arr[i];
  24.         arr[i]=arr[j];
  25.         arr[j]=temp;
  26.     }

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

堆排序

堆排序过程

堆排序在博主的这一篇文章有详细解释：堆排序和Top-K问题https://blog.csdn.net/m0_67995737/article/details/127292116

交换排序 

 基本思想：

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

冒泡排序： 

 冒泡排序在博主的这一篇文章有详细解释：【Java SE】实现冒泡排序和数组逆序https://blog.csdn.net/m0_67995737/article/details/126131273

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

快速排序： 

快速排序过程

基本思想： 

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止

快速排序

Hoare递归代码实现：

  1.     /**
  2.      * 快速排序(Hoare版)
  3.      * 时间复杂度：O(n*logn)
  4.      * 空间复杂度：O(logn)
  5.      * 稳定性：不稳定
  6.      * @param arr
  7.      * 问题：当我们给定的数据是有序的时候其时间复杂度为O(n^2),空间复杂度达到了O(n)
  8.      */
  9.     public void quickSort(int[]arr){
  10.         quick(arr,0,arr.length-1);
  11.     }
  12.  
  13.     private void quick(int[]arr,int start,int end){
  14.  
  15.         if(start>=end){
  16.             return;
  17.         }
  18.  
  19.         int pivot=pivotPartationHoare(arr,start,end);
  20.         quick(arr,start,pivot-1);
  21.         quick(arr,pivot+1,end);
  22.     }
  23.     //Hoare法
  24.     private int pivotPartationHoare(int[]arr,int left,int right){
  25.         int i=left;
  26.         int pivot=arr[left];
  27.  
  28.         while(left<right){
  29.  
  30.             //left<right不能少，否则会出现越界
  31.             while (left<right&&arr[right]>=pivot){
  32.                 right--;
  33.             }
  34.             while (left<right&&arr[left]<=pivot){
  35.                 left++;
  36.             }
  37.  
  38.             //都找到后交换
  39.             swap(arr,left,right);
  40.  
  41.         }
  42.  
  43.         //一边找完之后和原来的left交换
  44.         swap(arr,left,i);
  45.  
  46.         return left;//为新的基准
  47.  
  48.     }
  49.  
  50.     public void swap(int[]arr,int i,int j){
  51.         int temp=arr[i];
  52.         arr[i]=arr[j];
  53.         arr[j]=temp;
  54.     }
  55.

 挖坑法递归代码实现：

  1.     public void quickSort(int[]arr){
  2.         quick(arr,0,arr.length-1);
  3.     }
  4.  
  5.     private void quick(int[]arr,int start,int end){
  6.  
  7.         if(start>=end){
  8.             return;
  9.         }
  10.  
  11.         int pivot=pivotPartationHoare(arr,start,end);
  12.         quick(arr,start,pivot-1);
  13.         quick(arr,pivot+1,end);
  14.     }
  15.  
  16.         private int pivotPartation(int[]arr,int left,int right){
  17.         int i=left;
  18.         int pivot=arr[left];
  19.  
  20.         while(left<right){
  21.  
  22.             //left<right不能少，否则会出现越界
  23.             while (left<right&&arr[right]>=pivot){
  24.                 right--;
  25.             }
  26.             arr[left]=arr[right];
  27.             while (left<right&&arr[left]<=pivot){
  28.                 left++;
  29.             }
  30.  
  31.             arr[right]=arr[left];
  32.  
  33.             //都找到后交换
  34.             swap(arr,left,right);
  35.  
  36.         }
  37.  
  38.         //一边找完之后和原来的left交换
  39.         arr[left]=pivot;
  40.         //swap(arr,left,i);
  41.  
  42.         return left;//为新的基准
  43.  
  44.     }
  45.  
  46.         public void swap(int[]arr,int i,int j){
  47.         int temp=arr[i];
  48.         arr[i]=arr[j];
  49.         arr[j]=temp;
  50.     }

快排优化方法：

1. 三数取中法选key
2. 递归到小的子区间时，可以考虑使用插入排序

  1.     private static int partition(int[] array, int left, int right) {
  2.         int prev = left ;
  3.         int cur = left+1;
  4.         while (cur <= right) {
  5.             if(array[cur] < array[left] && array[++prev] != array[cur]) {
  6.                 swap(array,cur,prev);
  7.             }
  8.             cur++;
  9.         }
  10.         swap(array,prev,left);
  11.         return prev;
  12.     }
  13.  
  14.     /**
  15.      * 对指定区间的数据进行插入排序
  16.      * @param array
  17.      * @param left
  18.      * @param right
  19.      */
  20.     private void insertSort(int[] array,int left,int right) {
  21.         for (int i = left+1; i <= right; i++) {
  22.             int tmp = array[i];
  23.             int j = i-1;
  24.             for (; j >= left;j--) {
  25.                 if(array[j] > tmp) {
  26.                     array[j+1] = array[j];
  27.                 }else {
  28.                     //array[j+1] = tmp;
  29.                     break;
  30.                 }
  31.             }
  32.             array[j+1] = tmp;
  33.         }
  34.     }
  35.     private void quick(int[] array,int start,int end) {
  36.  
  37.         if(start >= end) {
  38.             return;
  39.         }
  40.  
  41.         if(end-start+1 <= 15) {
  42.             //对 start 和 end区间 范围内 使用插入排序
  43.             insertSort(array,start,end);
  44.             return;
  45.         }
  46.         //System.out.println("start: " +start +" end: "+end);
  47.  
  48.         // 在执行 partition 找基准之前，解决划分不均匀的问题
  49.         int index = findMidValOfIndex(array,start,end);
  50.         swap(array,start,index);
  51.  
  52.         int pivot = partition(array,start,end);
  53.         quick(array,start,pivot-1);
  54.         quick(array,pivot+1,end);
  55.     }
  56.  
  57.     private int findMidValOfIndex(int[] array,int start,int end) {
  58.         int midIndex = (start+end) / 2;
  59.         //    3                 9
  60.         if(array[start] < array[end]) {
  61.             if(array[midIndex] < array[start]) {
  62.                 return start;
  63.             }else if(array[midIndex] > array[end]) {
  64.                 return end;
  65.             }else {
  66.                 return midIndex;
  67.             }
  68.         }else {
  69.             if(array[midIndex] > array[start]) {
  70.                 return start;
  71.             }else if(array[midIndex] < array[end]) {
  72.                 return end;
  73.             }else {
  74.                 return midIndex;
  75.             }
  76.         }
  77.     }
  78.  
  79.  
  80.     /**
  81.      * 时间复杂度：O(N*logN)
  82.      * 空间复杂度：O(logN)
  83.      * 稳定性：不稳定的排序
  84.      * @param array
  85.      *
  86.      * 问题：
  87.      * 当我们给定的数据 是有序的时候，这个快排的时间复杂度是O(n^2)
  88.      * 空间复杂度：O(n)
  89.      */
  90.     public void quickSort1(int[] array) {
  91.         quick(array,0,array.length-1);
  92.     }

非递归实现：

  1.     public static void quickSort(int[] array) {
  2.         Stack<Integer> stack = new Stack<>();
  3.         int start = 0;
  4.         int end = array.length-1;
  5.         int pivot = partition(array,start,end);
  6.         //1.判断左边是不是有2个元素
  7.         if(pivot > start+1) {
  8.             stack.push(start);
  9.             stack.push(pivot-1);
  10.         }
  11.         //2.判断右边是不是有2个元素
  12.         if(pivot < end-1) {
  13.             stack.push(pivot+1);
  14.             stack.push(end);
  15.         }
  16.         while (!stack.isEmpty()) {
  17.             end = stack.pop();
  18.             start = stack.pop();
  19.             pivot = partition(array,start,end);
  20.             //3.判断左边是不是有2个元素
  21.             if(pivot > start+1) {
  22.                 stack.push(start);
  23.                 stack.push(pivot-1);
  24.             }
  25.             //4.判断右边是不是有2个元素
  26.             if(pivot < end-1) {
  27.                 stack.push(pivot+1);
  28.                 stack.push(end);
  29.             }
  30.         }
  31.  
  32.     }

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

归并排序 

归并排序过程

基本思想：

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

归并排序

 


 

 递归实现代码：

  1.    public void mergeSort1(int[] array) {
  2.         mergeSortChild(array,0,array.length-1);
  3.     }
  4.  
  5.     private void mergeSortChild(int[] array,int left,int right) {
  6.         if(left == right) {
  7.             return;
  8.         }
  9.         int mid = (left+right) / 2;
  10.         mergeSortChild(array,left,mid);
  11.         mergeSortChild(array,mid+1,right);
  12.         //合并
  13.         merge(array,left,mid,right);
  14.     }
  15.  
  16.     private void merge(int[] array,int left,int mid,int right) {
  17.         int s1 = left;
  18.         int e1 = mid;
  19.         int s2 = mid+1;
  20.         int e2 = right;
  21.         int[] tmpArr = new int[right-left+1];
  22.         int k = 0;//表示tmpArr 的下标
  23.         while (s1 <= e1  && s2 <= e2) {
  24.             if(array[s1] <= array[s2]) {
  25.                 tmpArr[k++] = array[s1++];
  26.             }else{
  27.                 tmpArr[k++] = array[s2++];
  28.             }
  29.         }
  30.         while (s1 <= e1) {
  31.             tmpArr[k++] = array[s1++];
  32.         }
  33.         while (s2 <= e2) {
  34.             tmpArr[k++] = array[s2++];
  35.         }
  36.         //tmpArr当中 的数据 是right  left 之间有序的数据
  37.         for (int i = 0; i < k; i++) {
  38.             array[i+left] = tmpArr[i];
  39.         }
  40.     }

非递归实现代码：

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

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

海量数据的排序问题
外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序
1. 先把文件切分成 200 份，每个 512 M
2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
3. 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

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

排序方法最好平均最坏空间复杂度稳定性
冒泡排序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)稳定


 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/968228
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号