你真的了解排序算法吗？

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量285 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49453641/article/details/124501736
版权

💖💖 大家好呀，欢迎来看我的文章😍，不求别的，希望各位大哥哥，小姐姐们能够给我一点点支持，让我这个萌新有前进的动力，太感谢啦，爱你们😙，哈哈哈💖

八大排序算法总结

一. 前言

我们通常所说的八大排序算法指的是：冒泡排序，插入排序，选择排序，希尔排序，快速排序，基数排序（桶排序），堆排序，归并排序

这么多的排序算法，究竟学习哪一种才是最好的呢，我们说，算法没有好坏之分，只有什么样的算法适合用在什么样的地方，如果你没有将一种算法用在它擅长的地方，那即使它是最好的算法也不能凸显出它的优势，所以这几种算法是我们每一个学习编程的同学都应该掌握的，至于哪一种算法适合用在什么地方，在下面的文章中我将会详细介绍。

二. 如何评价一个算法的好坏

评价一个算法的好坏主要从：时间复杂度，空间复杂度，正确性，可读性，健壮性来评价

2.1 时间负复杂度

时间复杂的是评价一个算法好坏最主要的因素，在计算机处理大量计算任务的时候，代码的执行效率成为了评判一个算法是否是一个优秀算法的关键，我们不可能花费大量的时间来等一个算法去执行吧，就像你买计算机不可能买那种运算素的特别慢的那种吧。

2.2 空间复杂度

算法的空间复杂度是指算法需要消耗的内存空间。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多，利用空间换时间的操作在大多数优秀算法都有存在，这种方法可以在利用部分内存空间的时候降低程序运行的时间（基数排序），不过我们一般可以将空间的花费忽略不计，因为在当今这个年代应该没有多少人买不起内存了吧，就连买一个手机都要买128gb的更别说电脑了。

2.3 正确性

算法的正确性是评价一个算法优劣的最重要的标准，不正确的算法何谈其他

2.4 可读性

如果你对一些代码比较复杂的算法感到反感的话也可以将代码复杂的放在评价一个算法的好坏上，不过我们并不推荐，因为程序主要是给计算机看的，不过依然要在保证其他项的同时保证程序的可读性。

2.5 健壮性

健壮性是指一个算法对不合理数据输入的反应能力和处理能力，也称为容错性，一个好的算法，他也将会有良好的健壮性。

2.6 八大排序算法的比较

三. 排序的基本概念

3.1 内部排序和外部排序

  1. 内部排序

    指在排序期间将待排序的数据都读入内存当中进行排序的一种方法，不和外部储存进行数据的交换

  2. 外部排序

    和外部排序差不多，只不过在排序期间和外存之间会进行数据的交换，通常是排序的数据量特别大的 时候，通过对一部分数据先进行排序，完了之后存储在外存中，待全部数据都进行排序之后再次将所有的数据都读入到内存当中

3.2 什么是稳定排序

  • 稳定排序：假定待排序的数组中存在A和B这两个数据，并且A和B都相等，假设等于0，并且A在B的前面，如果排序之后A任然在B的前面A和B未因为排序而交换位置（A和B交换位置是可能发生的，因为A和B相等）说明次排序是稳定排序，反之为不稳定排序

  • 不稳定排序：快速排序、希尔排序、堆排序

  • 稳定排序：冒泡排序，直接插入排序、归并排序、基数排序

  • 不确定：简单选择排序（插入版稳定，交换版不稳定）

四. 八大排序算法详解

4.1 冒泡排序

  1. 基本介绍：冒泡排序是排序算法当中最为基本的一种排序方式，为什么会叫冒泡排序呢？因为数组中的每一个数据都能够想泡泡一样逐步找到自己对应的位置（逐渐变大，或变小），并且冒泡排序每一轮只能确定一个数的位置

  2. 基本思想：每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面两个相邻的两个数大小关系，重复此步骤，直到最后一个还没归位的数。

  3. 实现图解：

  4. 代码实现：

public void bubbleSort(int[] array){
    for(int i=0;i<array.length-1;i++){//控制比较轮次，一共 n-1 趟
        for(int j=0;j<array.length-1-i;j++){//控制两个挨着的元素进行比较
            if(array[j] > array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
}
  1. 算法优化：上面的代码其实还可以被优化，因为如果数据本身就不是全部无序，那么我们就可以只进行无序的排列，有序的数据就可以不用进行排列，有序的排列了就是在做无用功
public static int[] bubbleSort(int[] arr) {
     if (arr == null || arr.length < 2) {
          return arr;
     }
    for (int i = 0; i < arr.length - 1; i++) {
         boolean isSorted  = true;//有序标记，每一轮的初始是true
         for (int j = 0; j < arr.length -i - 1; j++) {
             if (arr[j + 1] < arr[j]) {
                 isSorted  = false;//有元素交换，所以不是有序，标记变为false
                 int t = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = t;
             }
         }
         //一趟下来是否发生位置交换，如果没有交换直接跳出大循环
         if(isSorted )
              break;
     }
     return arr;
}

  1. 时间复杂的分析

    很显然，这就是一个等差数列，那么根据时间复杂度的计算方法就可以计算出算法所用的时间为：O(n^2)

4.2 插入排序

  1. 基本介绍：每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。
  2. 基本思想：第一次排序从数组中的第二个数开始，依次和前面的有序数组（已经排列好）进行比较，直到找到一个能插入这个数的位置，对于一个无序数组array{4,5,7,3,2,8}，而言，进行第一次排序的时候我们知道的就是第一个元素array[0] = 4是有序的，那进行第一次排序比较的时候就应该用第二个元素array[1] = 5和前面有序的数组进行比较，然而第一次比较之后可以发现，数组中的数并不需要交换位置，进行第二轮比较也不用交换位置，直到第三次交换之后才发现3比前面的数据小 ，这显然是不符合的，就应该将3交换位置，从上面的理论可以看出3应该排在第一位，进行三轮比较之后，得到的结果应该是这样的array{3,4,5,7,2,8}，按照这个比较方法依次进行比较最终得出结果，如图所示：
  3. 实现图解：

  1. 代码实现：
public class InsertSortTest { 
  public static void InsertSort(int[] source) { 
    int i, j; 
    int insertNode;// 要插入的数据 
    // 从数组的第二个元素开始循环将数组中的元素插入 
    for (i = 1; i < source.length; i++) { 
      // 设置数组中的第2个元素为第一次循环要插入的数据 
      insertNode = source[i]; 
      j = i - 1; 
      // 如果要插入的元素小于第j个元素，就将第j个元素向后移 
      while ((j >= 0) && insertNode < source[j]) { 
        source[j + 1] = source[j]; 
        j--;  
      } 
      // 直到要插入的元素不小于第j个元素,将insertNote插入到数组中 
      source[j + 1] = insertNode; 
      System.out.print("第" + i + "趟排序："); 
      printArray(source); 
    } 
  } 
 
  private static void printArray(int[] source) { 
    for (int i = 0; i < source.length; i++) { 
      System.out.print("\t" + source[i]); 
    } 
    System.out.println(); 
  } 
 
  public static void main(String[] args) { 
    int source[] = new int[] { 53, 27, 36, 15, 69, 42 }; 
    System.out.print("初始关键字："); 
    printArray(source); 
    System.out.println(""); 
    InsertSort(source); 
 
    System.out.print("\n\n排序后结果："); 
    printArray(source); 
  } 
 
}
  1. 时间复杂度分析

在排序过程中将后面的元素与前面的元素进行比较，总共进行了n-1次，每一次又分为两步

  • 和前一元素进行比较
  • 将前一元素进行往后挪

通过分析可知，该算法的时间复杂度为：O(n^2)

4.3 选择排序

  1. 基本介绍：每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止。
  2. 基本思路：每一趟通过不断地比较交换来使得首元素为当前最小，交换是一个比较耗时间的操作，我们可以通过设置一个值来记录较小元素的下标，循环结束后存储的就是当前最小元素的下标，这时再进行交换就可以了。对于数组一个无序数组{4，6，8，5，9}来说，我们以min来记录较小元素的小标，i和j结合来遍历数组，初始的时候min和i都指向数组的首元素，j指向下一个元素，j开始从右向左进行遍历数组元素，若有元素比min元素更小则进行交换，然后min为更小元素的小标，i再向右走，这样循环到i走到最后一个元素就完成了排序，过程如下图所示：
  3. 实现图解：

  1. 代码实现
public static void selectionSort(int[] nums) {

    if (nums == null || nums.length < 2) {
        return;
    }

    for(int i = 0; i < nums.length - 1; i++) {
        for(int j = i + 1; j < nums.length; j++) {
            if(nums[i] > nums[j]) {
                swap(nums, i, j);
            }
        }
    }

}

public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
  1. 算法优化
    ​上面的算法的缺点：在每趟比较过程中，只要发现比第一位要小的数据就交换他们，其实这是没必要 进行的操作，白白增加了交换的次数，降低了算法的效率。

​ 优化：其实我们只要找到每一趟中最小的那个数据将它和第一位数进行交换即可，可以定义一个新的索引，指向最小的那个数。

public static void selectionSort(int[] nums) {

    if (nums == null || nums.length < 2) {
        return;
    }

    for(int i = 0; i < nums.length - 1; i++) {
        int minIndex = i;
        for(int j = i + 1; j < nums.length; j++) {
            if(nums[i] > nums[j]) {
                minIndex = nums[j] < nums[minIndex] ? j : minIndex;
            }
        }
        swap(nums, i, minIndex);
    }

}
  1. 时间复杂度分析
    ​ 因为也是进行了n-1次的比较，所以经过分析可以直到次算法的时间复杂度为：O(n^2)。

4.4 希尔排序

  1. 基本介绍：希尔排序实际上是对插入排序进行的一次优化假设arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是：
    {2,3,4,5,6,6}
    {2,3,4,5,5,6}
    {2,3,4,4,5,6}
    {2,3,3,4,5,6}
    {2,2,3,4,5,6}
    {1,2,3,4,5,6}
    可以看出当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响。所以就发明了希尔排序。
  2. 基本思想：希尔排序需要定义一个增量，这里选择增量为gap=length/2，缩小增量以gap=gap/2的方式，这个增量可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列，这个增量是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。对于一个无序序列{8，9，1，7，2，3，5，4，6，0}来说，我们初始增量为gap=length/2=5，所以这个序列要被分为5组，分别是{8，3}，{9，5}，{1，4}，{7，6}，{2，0}，对这5组分别进行直接插入排序，则小的元素就被调换到了前面，然后再缩小增量gap=gap/2=2。
  3. 实现图解：

第一次分为8列进行比较

在这里插入图片描述

第二次分为4列进行比较

在这里插入图片描述

第三次分为2列进行比较

在这里插入图片描述

第四次分为1列进行比较

在这里插入图片描述

通过这几次的比较最终可以得到有序数组

  1. 代码实现
package sortdemo;

import java.util.Arrays;

/**
 * Created by chengxiao on 2016/11/24.
 */
public class ShellSort {
    public static void main(String []args){
        int []arr ={1,4,2,7,9,8,3,6};
        sort(arr);
        System.out.println(Arrays.toString(arr));
        int []arr1 ={1,4,2,7,9,8,3,6};
        sort1(arr1);
        System.out.println(Arrays.toString(arr1));
    }

    /**
     * 希尔排序 针对有序序列在插入时采用交换法
     * @param arr
     */
    public static void sort(int []arr){
        //增量gap，并逐步缩小增量
       for(int gap=arr.length/2;gap>0;gap/=2){
           //从第gap个元素，逐个对其所在组进行直接插入排序操作
           for(int i=gap;i<arr.length;i++){
               int j = i;
               while(j-gap>=0 && arr[j]<arr[j-gap]){
                   //插入排序采用交换法
                   swap(arr,j,j-gap);
                   j-=gap;
               }
           }
       }
    }

    /**
     * 希尔排序 针对有序序列在插入时采用移动法。
     * @param arr
     */
    public static void sort1(int []arr){
        //增量gap，并逐步缩小增量
        for(int gap=arr.length/2;gap>0;gap/=2){
            //从第gap个元素，逐个对其所在组进行直接插入排序操作
            for(int i=gap;i<arr.length;i++){
                int j = i;
                int temp = arr[j];
                if(arr[j]<arr[j-gap]){
                    while(j-gap>=0 && temp<arr[j-gap]){
                        //移动法
                        arr[j] = arr[j-gap];
                        j-=gap;
                    }
                    arr[j] = temp;
                }
            }
        }
    }
    /**
     * 交换数组元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a,int b){
        arr[a] = arr[a]+arr[b];
        arr[b] = arr[a]-arr[b];
        arr[a] = arr[a]-arr[b];
    }
}
  1. 时间复杂度分析：
    ​ 通过分析可以得出时间复杂度为：O(n^2)。

4.5 快速排序

  1. 基本介绍：

    快速排序是（Quick sort）是对冒泡排序的一种改进，是非常重要且应用比较广泛的一种高效率排序算法，之所以称为快速排序就是因为快了嘛

  2. 基本思路：

    其实实现的方法类似于二分查找，都是二分，不过，快速排序是将每一次二分之后的数据进行比较，使得一边的数据比另一边的数据小，之后再一次进行二分，使用递归的方法，进行持续的二分比较，最后得到排序之后的数据。进行二分的时候首先需要设置一个值，也叫中间值，然后利用这个中间值进行二分，递归

  3. 实现图解

  4. 代码实现：

public class QuickSort {
   public static void quickSort(int [] arr,int left,int right) {

      int pivot=0;

      if(left<right) {

         pivot=partition(arr,left,right);

         quickSort(arr,left,pivot-1);

         quickSort(arr,pivot+1,right);

      }

   }

   private static int partition(int[] arr,int left,int right) {

      int key=arr[left];

      while(left<right) {

         while(left<right && arr[right]>=key) {

            right--;

         }

         arr[left]=arr[right];

         while(left<right && arr[left]<=key) {

            left++;

         }

         arr[right]=arr[left];

      }

      arr[left]=key;

      return left;

   }
   public static void main(String[] args) {

      int arr[]= {65,58,95,10,57,62,13,106,78,23,85};

      System.out.println("排序前："+Arrays.toString(arr));

      quickSort(arr,0,arr.length-1);

      System.out.println("排序后："+Arrays.toString(arr));

   }

}

  1. 时间复杂度分析：

    快速排序在每次分割的过程中，需要 1 个空间存储基准值。而快速排序的大概需要 logN次的分割处理，所以占用空间也是 logN 个，经过分析可知，算法的时间复杂度为：O(log2^n)。

4.6 基数排序

  1. 基本介绍：

    基数排序(Radix Sort)是桶排序的扩展，它的基本思想是：将整数按位数切割成不同的数字，然后按每个位数分别比较。具体做法是：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

  2. 基本思路：

    创建一个二位数组来存储每一遍历之后的数据，这个二维数组的行必须是10，列的话是数据的大小（待排序数组的长度），然后分别进行个为十位…的比较，将比较的值放正桶里面，每一次比较之后更新原始数组，然后再一次进行比较，最后代所有位都比较完毕之后得到的数据就是排序好的数据。

  3. 实现图解

    1. 代码实现
    package com.radixSort;

import java.util.Arrays;

/**
 * @author Mr.sun
 */
public class radixSort {
    public static void main(String[] args) {
        //创建一个待排序数组
        int[] array ={548,123,678,3,10,78,};
        //这只是第一轮循环，循环的次数受到待排序中最高位数的影响，如果一轮排序结束之后发现所有数据mod上一个10之后的数都是0
        //说明排序结束，还要一种方法，每一次mod数的时候检查是否为0，如果不是0就在变量上加一，最后如果变量为1则说明循环还剩余一次
        //最后循环一次之后就可以结束这个程序
        int[] radixSortTest = radixSortTest(array);
        System.out.println(Arrays.toString(radixSortTest));
    }
    public static int[] radixSortTest(int[] array){
        //创建一个二维数组来表示桶
        int length = array.length;
        int[][] buckets= new int [10][length];
        int[] arrayElementsCount = new int[10];
        int temp = 0;
        int index = 0;
        int k = 0;
        //遍历每一个待排序数组里面的数据将数据利用循环将第一轮的数据存储在桶里面
        do{
            temp = 0;
            for(int i = 0;i<length;i++){
                int digit = (array[i]/(int)(Math.pow(10,k)))%10;
                if(array[i]/(int)(Math.pow(10,k))!=0){
                    temp++;
                }
                //将数据存储到桶里面
                buckets[digit][arrayElementsCount[digit]] = array[i];
                arrayElementsCount[digit]++;
            }
            //将数据从桶里面取出来
            for(int j = 0;j<10;j++){
                if(arrayElementsCount[j] !=0){
                    for(int l = 0;l<arrayElementsCount[j];l++){
                        array[index++] = buckets[j][l];
                    }
                    arrayElementsCount[j] =0;
                }
            }
            index = 0;
            k++;
        }while(temp-1>=0);
        return array;
    }
}
    1. 时间复杂度分析
      这个时间复杂度跟数的位数有关。这个数位可以理解为常数级。但是每一次又需要对数进行排序。而基数排序通常搭配的是计数排序。而计数排序的时间复杂度是 O(n)的线性的。忽略常数项，因此基数排序的时间复杂度是 O(n)的

4.7 堆排序

  1. 基本介绍：

    要理解堆排序首先就要理解堆，堆不是一种算法，而是一种数据结构，一种叫做完全二叉树的数据结构。虽然我之前学习过堆，但是对堆的理解还不够透彻，这里就先不向大家介绍堆了，到后面我深入学习有关堆的知识之后再向大家介绍堆相关的内容。

4.8 归并排序

  1. 基本介绍：

    归并排序，顾名思义就是归，但在归的前提是要分，这里主要是利用到分治的思想，将大问题都按照一定的规则分为若干小问题，然后再解决这些小问题，最后大问题得到求解

  2. 基本实现思路：把数组从中间划分成两个子数组;一直递归地把子数组划分成更小的子数组，直到子数组里面只有一个元素，依次按照递归的返回顺序，不断地合并排好序的子数组，直到最后把整个数组的顺序排好。看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现的详细步骤

  3. 实现图解：

image-20220429180704616

  1. 代码实现：
package sortdemo;

import java.util.Arrays;

/**
 * Created by chengxiao on 2016/12/8.
 */
public class MergeSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        sort(arr,0,arr.length-1,temp);
    }
    private static void sort(int[] arr,int left,int right,int []temp){
        if(left<right){
            int mid = (left+right)/2;
            sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

  1. 时间复杂度分析

    归并排序的时间复杂度是O(NlgN)。
    假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？
    归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(NlgN)。

这就是我目前能总结的关于排序算法的知识啦，希望各位大佬能给我指出问题，谢谢啦，我会继续努力的。
部分图片来源于网络，侵权删。

@若离风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++排序算法：归并排序详解
小天狼星_布莱克 的博客
07-17 3万+
C++排序算法：归并排序详解
Python排序算法，冒泡排序
10-28
了解这些排序算法的概念和实现方式对于提升编程能力非常重要，它们不仅帮助我们理解数据结构和算法，还能在面对不同场景时选择合适的排序方法。在实际应用中，通常会优先考虑使用内置的高效排序函数，但在学习和理解...
9大排序算法，你了解多少？
程序大视界
09-14 667
0. 前言 大家好，我是多选参数的程序锅，一个正在捣鼓操作系统、学数据结构和算法以及 Java 的失业人员。数据结构和算法我已经学了有一段日子了，最近也开始在刷 LeetCode 上面的题目了，但是自己感觉在算法上还是 0 ，还得猛补啊。 今天这篇基于之前的 8 大排序算法基础之上，增加一个堆排序，也就是这么 9 个排序算法：冒泡排序、插入排序、选择排序、归并排序、快速排序、堆排序、桶排序、计数排序、基数排序。它们对应的时间复杂度如下所示： 排序算法 时间复杂度 是否基于比较 冒泡、插
Java 数据结构篇-深入了解排序算法（动态图 + 实现七种基本排序算法）
小扳手
01-28 7643
1.0 冒泡排序的实现 + 动态演示图 2.0 选择排序的实现 + 动态演示图 3.0 堆排序的实现 + 动态演示图 4.0 插入排序的实现 + 动态演示图 5.0 希尔排序的实现 + 动态演示图 6.0 归并排序的实现 + 动态演示图 7.0 快速排序的实现 + 动态演示图
【算法系列 | 6】深入解析排序算法之——堆排序
颜淡慕潇
06-13 1万+
堆排序（Heap Sort）是一种基于堆数据结构的排序算法，其核心思想是将待排序的序列构建成一个最大堆（或最小堆），然后将堆顶元素与最后一个元素交换，再将剩余元素重新调整为最大堆（或最小堆），重复以上步骤直到所有元素都有序。
【算法系列 | 1】深入解析排序算法之——冒泡排序
颜淡慕潇
06-02 1万+
这些排序算法各有特点，可以根据具体需求选择适合的算法。在实际应用中，常常需要综合考虑时间复杂度、空间复杂度、稳定性等因素进行选择。
排序算法：堆排序
Yikefore的博客
05-28 2689
关于排序算法中的堆排序的详细介绍，以及实现过程和时间复杂度的计算，附带图解。
【算法系列 | 4】深入解析排序算法之——归并排序
热门推荐
颜淡慕潇
06-10 2万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）归并排序（Merge Sort）是一种基于分治思想的排序算法，它将待排序的数组分成两部分，分别对这两部分递归地进行排序，最后将两个有序子数组合并成一个有序数组。
【算法系列 | 3】深入解析排序算法之——选择排序
颜淡慕潇
06-09 1万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）选择排序（Selection Sort）是一种简单的排序算法，其基本原理是在未排序的元素中找到最小（或最大）的元素，然后将其放在已排序的序列的末尾。重复这个过程，直到所有元素都被排序完毕。
常见排序算法汇总
夜槿笙歌的博客
04-17 8285
整理一下之前学习的各种排序算法
带你手撕排序算法
Ruiren_的博客
02-01 4536
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。实际中我们玩扑克牌时，就用了插入排序的思想
十大经典排序算法.pdf
12-08
十大经典排序算法是数据结构与算法领域中的基础，它们包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、...了解并掌握这些排序算法是理解数据结构与算法的基础，有助于在实际编程中做出更明智的选择。
Python排序算法详解
04-10
Python作为一门简洁且强大的编程语言，内置了高效的排序函数`sorted()`和列表对象的`sort()`方法，但了解和掌握排序算法的原理对于优化代码性能和解决复杂问题至关重要。下面我们将逐一探讨Python中的五种主要排序...
java-排序算法总结
02-27
在编程领域，排序算法是计算机科学中的...了解和掌握这些排序算法的原理和Java实现，能帮助我们更好地解决实际问题，提高代码性能。同时，提供的范文、模板和素材可以作为学习和参考的宝贵资源，帮助初学者快速上手。
c语言基础包括排序算法
03-16
了解并熟练掌握这些排序算法有助于提升解决实际问题的能力。通过C语言实现这些算法，可以更好地理解它们的工作原理，并优化算法性能。 在"C-Learning-master (2).zip"这个压缩包中，可能包含了关于C语言基础教程和...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1260
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 807
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 364
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 493
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
你了解几种排序算法？可以说一下这些排序算法的时间复杂度吗？有没有一种时间复杂度为O(N) 的排序算法？
09-21
当然，我了解几种常见的排序算法，包括冒泡排序、选择排序、插入排序、归并排序和快速排序等。以下是这些排序算法的时间复杂度： 1. 冒泡排序：最坏情况下的时间复杂度为O(N^2)，最好情况下的时间复杂度为O(N)，平均情况下的时间复杂度为O(N^2)。 2. 选择排序：最坏情况下的时间复杂度为O(N^2)，最好情况下的时间复杂度为O(N^2)，平均情况下的时间复杂度为O(N^2)。 3. 插入排序：最坏情况下的时间复杂度为O(N^2)，最好情况下的时间复杂度为O(N)，平均情况下的时间复杂度为O(N^2)。 4. 归并排序：最坏情况下的时间复杂度为O(NlogN)，最好情况下的时间复杂度为O(NlogN)，平均情况下的时间复杂度为O(NlogN)。 5. 快速排序：最坏情况下的时间复杂度为O(N^2)，最好情况下的时间复杂度为O(NlogN)，平均情况下的时间复杂度为O(NlogN)。 是的，有一种时间复杂度为O(N)的排序算法，称为计数排序。计数排序适用于元素范围不大的情况，它通过统计每个元素出现的次数，然后依次输出来实现排序，时间复杂度为O(N)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@若离风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值