排序算法总结

最新推荐文章于 2025-05-02 23:16:03 发布

fuli_fox

最新推荐文章于 2025-05-02 23:16:03 发布

阅读量239

点赞数

分类专栏：算法文章标签：排序算法

本文链接：https://blog.youkuaiyun.com/yuanfuli/article/details/102695187

版权

算法专栏收录该内容

4 篇文章

订阅专栏

排序算法总结

简介

排序算法是程序员必须掌握的基础算法，其中分为内部排序和外部排序，其中内部排序是指只用到了电脑内存而不使用外存的排序方式，相对的外部排序就是同时使用了电脑内存和外存的排序方式。本文这里只讨论内部排序。

对于排序算法，可以按照不同的标准进行分类，有基于比较和非比较的排序，比较在这里是指需要比较两个元素的大小（前后）才能进行的排序，大多数排序算法是基于比较的，非比较排序算法有：计数排序、桶排序、基数排序，它们用统计的方法规避了排序，详细的可查看后面讲到的这些算法；还有基于稳定性对排序算法进行分类，其中稳定性：描述算法对原始序列处理前后，该序列相等大小的元素前后位置是否发生改变，如果是稳定算法的话，我们可以先排序名，再排序姓。

排序算法	平均时间复杂度	稳定性
冒泡排序	O(n^2)	稳定
选择排序	O(n^2)	不稳定
插入排序	O(n^2)	稳定
希尔排序	O(n^1.5)	不稳定
快速排序	O(NlogN)	不稳定
归并排序	O(NlogN)	稳定
堆排序	O(NlogN)	不稳定
基数排序	O(d(n+r))	稳定

各种排序算法比价

冒泡排序

基本思想：依次比较相邻两元素，若前一元素大于后一元素则交换之，直至最后一个元素即为最大；然后重新从首元素开始重复同样的操作，直至倒数第二个元素即为次大元素；依次类推。如同水中的气泡，依次将最大或最小元素气泡浮出水面。
过程：
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
时间复杂度：O(N²)
稳定性：稳定
代码实现：

public static void BubbleSort(int [] arr){
     int temp;//临时变量
     for(int i=0; i<arr.length-1; i++){   //表示趟数，一共arr.length-1次。
         for(int j=arr.length-1; j>i; j--){
             if(arr[j] < arr[j-1]){
                 temp = arr[j];
                 arr[j] = arr[j-1];
                 arr[j-1] = temp;
             }
         }
     }
 }

选择排序

基本思想：首先初始化最小元素索引值为首元素，依次遍历待排序数列，若遇到小于该最小索引位置处的元素则刷新最小索引为该较小元素的位置，直至遇到尾元素，结束一次遍历，并将最小索引处元素与首元素交换；然后，初始化最小索引值为第二个待排序数列元素位置，同样的操作，可得到数列第二个元素即为次小元素；以此类推。
过程：
- 初始状态：无序区为R[1…n]，有序区为空；
- 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
时间复杂度：O(N²)
稳定性：不稳定
代码实现：

public static void select_sort(int array[],int lenth){
   for(int i=0;i<lenth-1;i++){
       int minIndex = i;
       for(int j=i+1;j<lenth;j++){
          if(array[j]<array[minIndex]){
              minIndex = j;
          }
       }
       if(minIndex != i){
           int temp = array[i];
           array[i] = array[minIndex];
           array[minIndex] = temp;
       }
   }
}

插入排序

基本思想：数列前面部分看为有序，依次将后面的无序数列元素插入到前面的有序数列中，初始状态有序数列仅有一个元素，即首元素。在将无序数列元素插入有序数列的过程中，采用了逆序遍历有序数列，相较于顺序遍历会稍显繁琐，但当数列本身已近排序状态效率会更高。
过程：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
时间复杂度：O(N²)
稳定性：稳定
代码实现：

public static void  insert_sort(int array[],int lenth){
   int temp;
   for(int i=0;i<lenth-1;i++){
       for(int j=i+1;j>0;j--){
           if(array[j] < array[j-1]){
               temp = array[j-1];
               array[j-1] = array[j];
               array[j] = temp;
           }else{         //不需要交换
               break;
           }
       }
   }
}

希尔排序

基本思想：插入排序的改进版。为了减少数据的移动次数，在初始序列较大时取较大的步长，通常取序列长度的一半，此时只有两个元素比较，交换一次；之后步长依次减半直至步长为1，即为插入排序，由于此时序列已接近有序，故插入元素时数据移动的次数会相对较少，效率得到了提高。
过程：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
时间复杂度：通常认为是O(N^3/2) ，未验证
稳定性：不稳定
代码实现：

public static void shell_sort(int array[],int lenth){
   int temp = 0;
   int incre = lenth;
   while(true){
       incre = incre/2;
       for(int k = 0;k<incre;k++){    //根据增量分为若干子序列
           for(int i=k+incre;i<lenth;i+=incre){
               for(int j=i;j>k;j-=incre){
                   if(array[j]<array[j-incre]){
                       temp = array[j-incre];
                       array[j-incre] = array[j];
                       array[j] = temp;
                   }else{
                       break;
                   }
               }
           }
       }
       if(incre == 1){
           break;
       }
   }
}

快速排序

基本思想：选一基准元素key，依次将剩余元素中小于该基准元素的值放置其左侧，大于等于该基准元素的值放置其右侧；然后，取基准元素的前半部分和后半部分分别进行同样的处理；以此类推，直至各子序列剩余一个元素时，即排序完成（类比二叉树的思想，from up to down）
过程：（分治思想）
- 先从数列中取出一个数作为key值；
- 将比这个数小的数全部放在它的左边，大于或等于它的数全部放在它的右边；
- 对左右两个小数列重复第二步，直至各区间只有1个数。
时间复杂度：O(NlogN)
稳定性：不稳定
代码实现：

public static void quickSort(int a[],int l,int r){
     if(l>=r)
       return;
     int i = l; int j = r; int key = a[l];//选择第一个数为key
     while(i<j){
         while(i<j && a[j]>=key)//从右向左找第一个小于key的值
             j--;
         if(i<j){
             a[i] = a[j];
             i++;
         }
         while(i<j && a[i]<key)//从左向右找第一个大于key的值
             i++;
         if(i<j){
             a[j] = a[i];
             j--;
         }
     }
     //i == j
     a[i] = key;
     quickSort(a, l, i-1);//递归调用
     quickSort(a, i+1, r);//递归调用
 }

归并排序

基本思想：归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。采用了分治和递归的思想，递归&分治-排序整个数列如同排序两个有序数列，依次执行这个过程直至排序末端的两个元素，再依次向上层输送排序好的两个子列进行排序直至整个数列有序（类比二叉树的思想，from down to up）。
过程：（分治思想）
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
时间复杂度：O(NlogN)
稳定性：稳定
代码实现：

public static void merge_sort(int a[],int first,int last,int temp[]){
  if(first < last){
      int middle = (first + last)/2;
      merge_sort(a,first,middle,temp);//左半部分排好序
      merge_sort(a,middle+1,last,temp);//右半部分排好序
      mergeArray(a,first,middle,last,temp); //合并左右部分
  }
}
//合并 ：将两个序列a[first-middle],a[middle+1-end]合并
public static void mergeArray(int a[],int first,int middle,int end,int temp[]){    
  int i = first;
  int m = middle;
  int j = middle+1;
  int n = end;
  int k = 0;
  while(i<=m && j<=n){//从两个数列a，b中，谁小就取谁
      if(a[i] <= a[j]){
          temp[k] = a[i];
          k++;
          i++;
      }else{
          temp[k] = a[j];
          k++;
          j++;
      }
  }    
  while(i<=m){ //有一个数列空了，剩下的挨个放进去
      temp[k] = a[i];
      k++;
      i++;
  }    
  while(j<=n){
      temp[k] = a[j];
      k++;
      j++;
  }

  for(int ii=0;ii<k;ii++){
      a[first + ii] = temp[ii];
  }
}

堆排序

基本思想：堆排序的思想借助于二叉堆中的最大堆得以实现。首先，将待排序数列抽象为二叉树，并构造出最大堆；然后，依次将最大元素（即根节点元素）与待排序数列的最后一个元素交换（即二叉树最深层最右边的叶子结点元素）；每次遍历，刷新最后一个元素的位置（自减1），直至其与首元素相交，即完成排序。
过程：
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
- 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=r[n]；
- 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
时间复杂度：O(NlogN)
稳定性：不稳定
代码实现：

//构建最小堆
public static void MakeMinHeap(int a[], int n){
 for(int i=(n-1)/2 ; i>=0 ; i--){
     MinHeapFixdown(a,i,n);
 }
}
//从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2  
public static void MinHeapFixdown(int a[],int i,int n){
   int j = 2*i+1; //子节点
   int temp = 0;
   while(j<n){
       //在左右子节点中寻找最小的
       if(j+1<n && a[j+1]<a[j]){  
           j++;
       }
       if(a[i] <= a[j])
           break;
       //较大节点下移
       temp = a[i];
       a[i] = a[j];
       a[j] = temp;

       i = j;
       j = 2*i+1;
   }
}

public static void MinHeap_Sort(int a[],int n){
  int temp = 0;
  MakeMinHeap(a,n);
  for(int i=n-1;i>0;i--){
      temp = a[0];
      a[0] = a[i];
      a[i] = temp;
      MinHeapFixdown(a,0,i);
  }    
}

计数排序

基本思想：计数排序的算法的原理，其实是非常简单的，它不需要去跟其他元素比来比去，而是一开始就知道自己的位置，所以直接归位，在计数的该元素出现的词频数组里面，出现一次，就直接+1次即可，如果没有出现改位置就是0，最后该位置的词频，就是代表其在原始数组里面出现的次数，由于词频数组的index是从0开始，所以最后直接遍历输出这个数组里面的每一个大于0的元素值即可。数组当中的值有正有负啊。做一个简单的转化就行了：找到数组中最小元素，用元素值减去，这样一来，所有元素对应的下标就求出来了。
过程：
- 根据待排序集合中最大元素和最小元素的差值范围，申请额外空间；
- 遍历待排序集合，将每一个元素出现的次数记录到元素值对应的额外空间内；
- 对额外空间内数据进行计算，得出每一个元素的正确位置；
- 将待排序集合每一个元素移动到计算得出的正确位置上。
时间复杂度：计数排序不是基于比较的排序，所以它的排序效率是线性的，其平均时间复杂度和空间复杂度为O(n+k)。在特定的场景下（已知数组的最大最小值，切数组元素整体量不是很大的情况下）排序效率极高，而基于比较排序的算法，其时间复杂度基本逃脱不了O(nlogn)的魔咒。
稳定性：稳定
代码实现：

public int[] countSort(int[] a) {
    int[] b = new int[a.length];
    int max = a[0], min = a[0];
    for (int i : a) {
        if (i > max) {
            max = i;
        }
        if (i < min) {
            min = i;
        }
    }
    // 根据 a 中的最大值与最小值，求出辅助数组的最小长度
    int[] c = new int[max - min + 1];
    for (int i1 : a) {
        c[i1 - min] += 1;
    }
	// 进行一次累加操作之后，
	// 那么对于存在数个相等的元素 a[x]（假设为 a[x]_1，a[x]_2，...a[x]_last，
	//  其中 a[x]_last 为最后一个 a[x]，即在 a 中处于最右边位置的 a[x]）
	// 则在排序后，有 (c[i] - 1) 即为 a[x]_last 前面存在的元素个数。
	// 这样是保证排序结果稳定的前提
    for (int i = 1; i < c.length; ++i) {
        c[i] = c[i] + c[i - 1];
    }
    // 倒着遍历 a，则可以先遍历到 a[x]_last，从而根据 c[y] 的值来确定其稳定的位置
    for (int i = a.length - 1; i >= 0; --i) {
        int pos = a[i] - min;// pos 为 a[i] 映射到 c 中的下标
        int sumCount = c[pos];
        b[sumCount - 1] = a[i];
        --c[pos];
    }
    
    return b;
}

桶排序

基本思想：实现线性排序，但当元素间值得大小有较大差距时会带来内存空间的较大浪费。首先，找出待排序列中得最大元素max，申请内存大小为max + 1的桶（数组）并初始化为0；然后，遍历排序数列，并依次将每个元素作为下标的桶元素值自增1；最后，遍历桶元素，并依次将值非0的元素下标值载入排序数列（桶元素>1表明有值大小相等的元素，此时依次将他们载入排序数列），遍历完成，排序数列便为有序数列。
过程：
- 设置一个定量的数组当作空桶；
- 遍历输入数据，并且把数据一个一个放到对应的桶里去；
- 对每个不是空的桶进行排序；
- 从不是空的桶里把排好序的数据拼接起来。
时间复杂度：
- 平均时间复杂度：O(n + k)
- 最佳时间复杂度：O(n + k)
- 最差时间复杂度：O(n ^ 2)
- 空间复杂度：O(n * k)
稳定性：稳定
代码实现：

public static void sort(int[] array) {
        // 确定元素的最值
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < array.length; i++) {
            max = Math.max(max, array[i]);
            min = Math.min(min, array[i]);
        }
        // 桶数：(max - min) / array.length的结果为数组大小的倍数（最大倍数），以倍数作为桶数
        int bucketNum = (max - min) / array.length + 1;
        // 初始化桶
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
        for (int i = 0; i < bucketNum; i++) {
            bucketArr.add(new ArrayList<Integer>());
        }
        // 将每个元素放入桶
        for (int i = 0; i < array.length; i++) {
            // 计算每个(array[i] - min)是数组大小的多少倍，看看放入哪个桶里
            int num = (array[i] - min) / (array.length);
            bucketArr.get(num).add(array[i]);
        }
        // 对每个桶进行排序
        for (int i = 0; i < bucketArr.size(); i++) {
            Collections.sort(bucketArr.get(i));
        }
        // 合并数据
        int j = 0;
        for (ArrayList<Integer> tempList : bucketArr) {
            for (int i : tempList) {
                array[j++] = i;
            }
        }
    }

基数排序

基本思想：桶排序的改进版，桶的大小固定为10，减少了内存空间的开销。首先，找出待排序列中得最大元素max，并依次按max的低位到高位对所有元素排序；桶元素10个元素的大小即为待排序数列元素对应数值为相等元素的个数，即每次遍历待排序数列，桶将其按对应数值位大小分为了10个层级，桶内元素值得和为待排序数列元素个数。
过程：
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
时间复杂度：基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n)
稳定性：稳定
代码实现：

public static void RadixSort(int A[],int temp[],int n,int k,int r,int cnt[]){

   //A:原数组
   //temp:临时数组
   //n:序列的数字个数
   //k:最大的位数2
   //r:基数10
   //cnt:存储bin[i]的个数
   for(int i=0 , rtok=1; i<k ; i++ ,rtok = rtok*r){

       //初始化
       for(int j=0;j<r;j++){
           cnt[j] = 0;
       }
       //计算每个箱子的数字个数
       for(int j=0;j<n;j++){
           cnt[(A[j]/rtok)%r]++;
       }
       //cnt[j]的个数修改为前j个箱子一共有几个数字
       for(int j=1;j<r;j++){
           cnt[j] = cnt[j-1] + cnt[j];
       }
       for(int j = n-1;j>=0;j--){      //重点理解
           cnt[(A[j]/rtok)%r]--;
           temp[cnt[(A[j]/rtok)%r]] = A[j];
       }
       for(int j=0;j<n;j++){
           A[j] = temp[j];
       }
   }
}