更细致的排序算法总结

移动开发 算法
排序算法是最基本最常用的算法,不同的排序算法在不同的场景或应用中会有不同的表现,我们需要对各种排序算法熟练才能将它们应用到实际当中,才能更好地发挥它们的优势。今天,来总结下各种排序算法。
排序算法 平均时间复杂度
冒泡排序 O(n2)
选择排序 O(n2)
插入排序 O(n2)
希尔排序 O(n1.5)
快速排序 O(N*logN)
归并排序 O(N*logN)
堆排序 O(N*logN)
基数排序 O(d(n+r))

一. 冒泡排序(BubbleSort)

  1. 基本思想:两个数比较大小,较大的数下沉,较小的数冒起来。

  2. 过程:

    • 比较相邻的两个数据,如果第二个数小,就交换位置。
    • 从后向前两两比较,一直到比较最前两个数据。最终最小数被交换到起始的位置,这样***个最小数的位置就排好了。
    • 继续重复上述过程,依次将第2.3...n-1个最小数排好位置。

      冒泡排序
  3. 平均时间复杂度:O(n2)

  4. java代码实现:

    1. public static void BubbleSort(int [] arr){ 
    2.  
    3.      int temp;//临时变量 
    4.      for(int i=0; i<arr.length-1; i++){   //表示趟数,一共arr.length-1次。 
    5.          for(int j=arr.length-1; j>i; j--){ 
    6.  
    7.              if(arr[j] < arr[j-1]){ 
    8.                  temp = arr[j]; 
    9.                  arr[j] = arr[j-1]; 
    10.                  arr[j-1] = temp; 
    11.              } 
    12.          } 
    13.      } 
    14.  } 
  5. 优化:

    • 针对问题:
      数据的顺序排好之后,冒泡算法仍然会继续进行下一轮的比较,直到arr.length-1次,后面的比较没有意义的。

    • 方案:
      设置标志位flag,如果发生了交换flag设置为true;如果没有交换就设置为false。
      这样当一轮比较结束后如果flag仍为false,即:这一轮没有发生交换,说明数据的顺序已经排好,没有必要继续进行下去。

      1. public static void BubbleSort1(int [] arr){ 
      2.  
      3.    int temp;//临时变量 
      4.    boolean flag;//是否交换的标志 
      5.    for(int i=0; i<arr.length-1; i++){   //表示趟数,一共arr.length-1次。 
      6.  
      7.        flag = false
      8.        for(int j=arr.length-1; j>i; j--){ 
      9.  
      10.            if(arr[j] < arr[j-1]){ 
      11.                temp = arr[j]; 
      12.                arr[j] = arr[j-1]; 
      13.                arr[j-1] = temp; 
      14.                flag = true
      15.            } 
      16.        } 
      17.        if(!flag) break
      18.    } 

二. 选择排序(SelctionSort)

  1. 基本思想:
    在长度为N的无序数组中,***次遍历n-1个数,找到最小的数值与***个元素交换;
    第二次遍历n-2个数,找到最小的数值与第二个元素交换;
    。。。
    第n-1次遍历,找到最小的数值与第n-1个元素交换,排序完成。

  2. 过程:

    选择排序
  3. 平均时间复杂度:O(n2)

  4. java代码实现:

    1. public static void select_sort(int array[],int lenth){ 
    2.  
    3.    for(int i=0;i<lenth-1;i++){ 
    4.  
    5.        int minIndex = i; 
    6.        for(int j=i+1;j<lenth;j++){ 
    7.           if(array[j]<array[minIndex]){ 
    8.               minIndex = j; 
    9.           } 
    10.        } 
    11.        if(minIndex != i){ 
    12.            int temp = array[i]; 
    13.            array[i] = array[minIndex]; 
    14.            array[minIndex] = temp; 
    15.        } 
    16.    } 

三. 插入排序(Insertion Sort)

  1. 基本思想:
    在要排序的一组数中,假定前n-1个数已经排好序,现在将第n个数插到前面的有序数列中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。

  2. 过程:

    插入排序

    相同的场景
  3. 平均时间复杂度:O(n2)

  4. java代码实现:

    1. public static void  insert_sort(int array[],int lenth){ 
    2.  
    3.    int temp; 
    4.  
    5.    for(int i=0;i<lenth-1;i++){ 
    6.        for(int j=i+1;j>0;j--){ 
    7.            if(array[j] < array[j-1]){ 
    8.                temp = array[j-1]; 
    9.                array[j-1] = array[j]; 
    10.                array[j] = temp; 
    11.            }else{         //不需要交换 
    12.                break
    13.            } 
    14.        } 
    15.    } 

四. 希尔排序(Shell Sort)

  1. 前言:
    数据序列1: 13-17-20-42-28 利用插入排序,13-17-20-28-42. Number of swap:1;
    数据序列2: 13-17-20-42-14 利用插入排序,13-14-17-20-42. Number of swap:3;
    如果数据序列基本有序,使用插入排序会更加高效。

  2. 基本思想:
    在要排序的一组数中,根据某一增量分为若干子序列,并对子序列分别进行插入排序。
    然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,***进行插入排序。

  3. 过程:

    希尔排序
  4. 平均时间复杂度:

  5. java代码实现:

    1. public static void shell_sort(int array[],int lenth){ 
    2.  
    3.    int temp = 0
    4.    int incre = lenth; 
    5.  
    6.    while(true){ 
    7.        incre = incre/2
    8.  
    9.        for(int k = 0;k<incre;k++){    //根据增量分为若干子序列 
    10.  
    11.            for(int i=k+incre;i<lenth;i+=incre){ 
    12.  
    13.                for(int j=i;j>k;j-=incre){ 
    14.                    if(array[j]<array[j-incre]){ 
    15.                        temp = array[j-incre]; 
    16.                        array[j-incre] = array[j]; 
    17.                        array[j] = temp; 
    18.                    }else
    19.                        break
    20.                    } 
    21.                } 
    22.            } 
    23.        } 
    24.  
    25.        if(incre == 1){ 
    26.            break
    27.        } 
    28.    } 

五. 快速排序(Quicksort)

  1. 基本思想:(分治)

    • 先从数列中取出一个数作为key值;
    • 将比这个数小的数全部放在它的左边,大于或等于它的数全部放在它的右边;
    • 对左右两个小数列重复第二步,直至各区间只有1个数。
  2. 辅助理解:挖坑填数

    • 初始时 i = 0; j = 9; key=72
      由于已经将a[0]中的数保存到key中,可以理解成在数组a[0]上挖了个坑,可以将其它数据填充到这来。
      从j开始向前找一个比key小的数。当j=8,符合条件,a[0] = a[8] ; i++ ; 将a[8]挖出再填到上一个坑a[0]中。
      这样一个坑a[0]就被搞定了,但又形成了一个新坑a[8],这怎么办了?简单,再找数字来填a[8]这个坑。
      这次从i开始向后找一个大于key的数,当i=3,符合条件,a[8] = a[3] ; j-- ;将a[3]挖出再填到上一个坑中。
      数组:72 - 6 - 57 - 88 - 60 - 42 - 83 - 73 - 48 - 85
       0   1   2    3    4    5    6    7    8    9
    • 此时 i = 3; j = 7; key=72
      再重复上面的步骤,先从后向前找,再从前向后找。
      从j开始向前找,当j=5,符合条件,将a[5]挖出填到上一个坑中,a[3] = a[5]; i++;
      从i开始向后找,当i=5时,由于i==j退出。
      此时,i = j = 5,而a[5]刚好又是上次挖的坑,因此将key填入a[5]。
      数组:48 - 6 - 57 - 88 - 60 - 42 - 83 - 73 - 88 - 85
       0   1   2    3    4    5    6    7    8    9
    • 可以看出a[5]前面的数字都小于它,a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。
      数组:48 - 6 - 57 - 42 - 60 - 72 - 83 - 73 - 88 - 85
       0   1   2    3    4    5    6    7    8    9
  3. 平均时间复杂度:O(N*logN)

  4. 代码实现:

    1. public static void quickSort(int a[],int l,int r){ 
    2.      if(l>=r) 
    3.        return
    4.  
    5.      int i = l; int j = r; int key = a[l];//选择***个数为key 
    6.  
    7.      while(i<j){ 
    8.  
    9.          while(i<j && a[j]>=key)//从右向左找***个小于key的值 
    10.              j--; 
    11.          if(i<j){ 
    12.              a[i] = a[j]; 
    13.              i++; 
    14.          } 
    15.  
    16.          while(i<j && a[i]<key)//从左向右找***个大于key的值 
    17.              i++; 
    18.  
    19.          if(i<j){ 
    20.              a[j] = a[i]; 
    21.              j--; 
    22.          } 
    23.      } 
    24.      //i == j 
    25.      a[i] = key; 
    26.      quickSort(a, l, i-1);//递归调用 
    27.      quickSort(a, i+1, r);//递归调用 
    28.  } 

    key值的选取可以有多种形式,例如中间数或者随机数,分别会对算法的复杂度产生不同的影响。

六. 归并排序(Merge Sort)

  1. 基本思想:参考
    归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。
    首先考虑下如何将2个有序数列合并。这个非常简单,只要从比较2个数列的***个数,谁小就先取谁,取了后就在对应数列中删除这个数。然后再进行比较,如果有数列为空,那直接将另一个数列的数据依次取出即可。

    1. //将有序数组a[]和b[]合并到c[]中 
    2. void MemeryArray(int a[], int n, int b[], int m, int c[]) 
    3.  int i, j, k; 
    4.  
    5.  i = j = k = 0
    6.  while (i < n && j < m) 
    7.  { 
    8.      if (a[i] < b[j]) 
    9.          c[k++] = a[i++]; 
    10.      else 
    11.          c[k++] = b[j++];  
    12.  } 
    13.  
    14.  while (i < n) 
    15.      c[k++] = a[i++]; 
    16.  
    17.  while (j < m) 
    18.      c[k++] = b[j++]; 

    解决了上面的合并有序数列问题,再来看归并排序,其的基本思路就是将数组分成2组A,B,如果这2组组内的数据都是有序的,那么就可以很方便的将这2组数据进行排序。如何让这2组组内数据有序了?
    可以将A,B组各自再分成2组。依次类推,当分出来的小组只有1个数据时,可以认为这个小组组内已经达到了有序,然后再合并相邻的2个小组就可以了。这样通过先递归的分解数列,再合并数列就完成了归并排序。

  2. 过程:

    归并排序
  3. 平均时间复杂度:O(NlogN)
    归并排序的效率是比较高的,设数列长为N,将数列分开成小数列一共要logN步,每步都是一个合并有序数列的过程,时间复杂度可以记为O(N),故一共为O(N*logN)。

  4. 代码实现:

    1. public static void merge_sort(int a[],int first,int last,int temp[]){ 
    2.  
    3.   if(first < last){ 
    4.       int middle = (first + last)/2
    5.       merge_sort(a,first,middle,temp);//左半部分排好序 
    6.       merge_sort(a,middle+1,last,temp);//右半部分排好序 
    7.       mergeArray(a,first,middle,last,temp); //合并左右部分 
    8.   } 
    1. //合并 :将两个序列a[first-middle],a[middle+1-end]合并 
    2. public static void mergeArray(int a[],int first,int middle,int end,int temp[]){      
    3.   int i = first; 
    4.   int m = middle; 
    5.   int j = middle+1
    6.   int n = end; 
    7.   int k = 0;  
    8.   while(i<=m && j<=n){ 
    9.       if(a[i] <= a[j]){ 
    10.           temp[k] = a[i]; 
    11.           k++; 
    12.           i++; 
    13.       }else
    14.           temp[k] = a[j]; 
    15.           k++; 
    16.           j++; 
    17.       } 
    18.   }      
    19.   while(i<=m){ 
    20.       temp[k] = a[i]; 
    21.       k++; 
    22.       i++; 
    23.   }      
    24.   while(j<=n){ 
    25.       temp[k] = a[j]; 
    26.       k++; 
    27.       j++;  
    28.   } 
    29.  
    30.   for(int ii=0;ii<k;ii++){ 
    31.       a[first + ii] = temp[ii]; 
    32.   } 

七. 堆排序(HeapSort)

  1. 基本思想:
  2. 图示: (88,85,83,73,72,60,57,48,42,6)

    Heap Sort
  3. 平均时间复杂度:O(NlogN)
    由于每次重新恢复堆的时间复杂度为O(logN),共N - 1次重新恢复堆操作,再加上前面建立堆时N / 2次向下调整,每次调整时间复杂度也为O(logN)。二次操作时间相加还是O(N * logN)。

  4. java代码实现:

    1. //构建最小堆 
    2. public static void MakeMinHeap(int a[], int n){ 
    3.  for(int i=(n-1)/2 ; i>=0 ; i--){ 
    4.      MinHeapFixdown(a,i,n); 
    5.  } 
    6. //从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2   
    7. public static void MinHeapFixdown(int a[],int i,int n){ 
    8.  
    9.    int j = 2*i+1//子节点 
    10.    int temp = 0
    11.  
    12.    while(j<n){ 
    13.        //在左右子节点中寻找最小的 
    14.        if(j+1<n && a[j+1]<a[j]){    
    15.            j++; 
    16.        } 
    17.  
    18.        if(a[i] <= a[j]) 
    19.            break
    20.  
    21.        //较大节点下移 
    22.        temp = a[i]; 
    23.        a[i] = a[j]; 
    24.        a[j] = temp; 
    25.  
    26.        i = j; 
    27.        j = 2*i+1
    28.    } 

    1. public static void MinHeap_Sort(int a[],int n){ 
    2.   int temp = 0
    3.   MakeMinHeap(a,n); 
    4.  
    5.   for(int i=n-1;i>0;i--){ 
    6.       temp = a[0]; 
    7.       a[0] = a[i]; 
    8.       a[i] = temp;  
    9.       MinHeapFixdown(a,0,i); 
    10.   }      

八. 基数排序(RadixSort)

BinSort
  1. 基本思想:
    BinSort想法非常简单,首先创建数组A[MaxValue];然后将每个数放到相应的位置上(例如17放在下标17的数组位置);***遍历数组,即为排序后的结果。

  2. 图示:

    BinSort
  3. 问题:
    当序列中存在较大值时,BinSort 的排序方法会浪费大量的空间开销。
RadixSort
  1. 基本思想:
    基数排序是在BinSort的基础上,通过基数的限制来减少空间的开销。

  2. 过程:

    过程1

    过程2


    (1)首先确定基数为10,数组的长度也就是10.每个数34都会在这10个数中寻找自己的位置。
    (2)不同于BinSort会直接将数34放在数组的下标34处,基数排序是将34分开为3和4,***轮排序根据最末位放在数组的下标4处,第二轮排序根据倒数第二位放在数组的下标3处,然后遍历数组即可。

  3. java代码实现:

    1. public static void RadixSort(int A[],int temp[],int n,int k,int r,int cnt[]){ 
    2.  
    3.    //A:原数组 
    4.    //temp:临时数组 
    5.    //n:序列的数字个数 
    6.    //k:***的位数2 
    7.    //r:基数10 
    8.    //cnt:存储bin[i]的个数 
    9.  
    10.    for(int i=0 , rtok=1; i<k ; i++ ,rtok = rtok*r){ 
    11.  
    12.        //初始化 
    13.        for(int j=0;j<r;j++){ 
    14.            cnt[j] = 0
    15.        } 
    16.        //计算每个箱子的数字个数 
    17.        for(int j=0;j<n;j++){ 
    18.            cnt[(A[j]/rtok)%r]++; 
    19.        } 
    20.        //cnt[j]的个数修改为前j个箱子一共有几个数字 
    21.        for(int j=1;j<r;j++){ 
    22.            cnt[j] = cnt[j-1] + cnt[j]; 
    23.        } 
    24.        for(int j = n-1;j>=0;j--){      //重点理解 
    25.            cnt[(A[j]/rtok)%r]--; 
    26.            temp[cnt[(A[j]/rtok)%r]] = A[j]; 
    27.        } 
    28.        for(int j=0;j<n;j++){ 
    29.            A[j] = temp[j]; 
    30.        } 
    31.    } 
责任编辑:倪明 来源: 简书
相关推荐

2011-05-12 14:21:22

流行路由器QoS

2019-09-17 16:30:18

java排序算法

2015-08-26 10:13:55

排序算法总结

2011-04-20 14:07:37

冒泡排序

2011-04-20 13:56:08

选择排序

2011-04-20 14:19:00

希尔排序

2011-04-20 15:20:03

快速排序

2011-04-20 15:06:44

堆排序

2011-04-20 14:29:07

归并排序

2011-04-20 12:49:44

插入排序

2011-04-20 16:05:15

基数排序

2024-03-21 11:34:40

2021-09-04 23:40:53

算法程序员前端

2022-09-24 09:03:55

前端单元测试冒泡排序

2023-02-09 07:39:01

2021-11-10 09:17:18

程序员排序算法搜索算法

2021-06-30 09:27:58

鸿蒙HarmonyOS应用

2020-04-28 11:00:45

Go开源库HTTP

2023-10-05 09:01:05

插入排序对象序列log2i

2010-09-06 13:53:21

PPPoE协议
点赞
收藏

51CTO技术栈公众号