Java排序算法

最新推荐文章于 2023-06-27 14:16:23 发布
最新推荐文章于 2023-06-27 14:16:23 发布
阅读量236 收藏 1
点赞数
分类专栏： Java数据结构与算法 Java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40613029/article/details/104159262
版权

排序算法

一、概述

排序算法(Sort Algorithm)，排序是将一组数据依指定的顺序进行排列的过程

1. 分类

1.1 内部排序

将需要处理的所有数据都加载到**内部存储器(内存)**中进行排序

1.2 外部排序

数据量过大时，无法全部加载到内存中，需要借助外部存储器进行排序

2. 常见排序算法

在这里插入图片描述

二、算法的时间复杂度

1. 时间频度

一个算法花费的时间与算法中语句的执行次数成正比例，算法中语句的执行次数越多，则它花费的时间就越多。一个算法中的语句执行次数称为语句频度或时间频度，记为：T(n)

2. 举例说明

  • 2*n+20和2n随着n的增大，两个表达式的结果会逐渐接近
  • 2n2+3n+10和2n2随着n增大，两个表达式的值会逐渐接近
  • 随着n的增大，5n2+7n和3n2+2n结果逐渐接近

结论：

  1. 常数项可以忽略
  2. 低次项可以忽略
  3. 高次项系数可以忽略

3. 时间复杂度

  1. 一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n)的极限值为不等于零的常数，则称f(n)为T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n))为算法的渐进时间复杂度，简称时间复杂度

  2. T(n)不同，当时间复杂度可能相同。如：T(n)=n2+7n+6与T(n)=3n2+2n+2它们的T(n)不同但时间复杂度都为O(n^2)

  3. 计算方法：

    • 用常数1代替运行时间中所有加法常数
    • 修改后的运行次数中只保留最高阶项
    • 去除最高阶项的系数

4. 常见的时间复杂度

  • 常数阶O(1)
  • 对数阶O([外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6QUEp7AU-1580721678273)(F:\Java笔记\图片\对数公式.png)])
  • 线性阶O(n)
  • 线性对数阶O(n[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NJp1bpyD-1580721678274)(F:\Java笔记\图片\对数公式.png)])
  • 平方阶O(n^2)
  • 立方阶O(n^3)
  • k次方阶O(n^k)
  • 指数阶O(2^n)

说明：

  • 常见的算法复杂度由小到大依次为：O(1)<O(在这里插入图片描述)<O(n)<O(n在这里插入图片描述)<O(n2)<O(n3)<O(nk)<O(2n)，随着问题规模的不断增大，上述时间复杂度不断增大，算法执行效率越低
排序法平均时间最差时间稳定度额外空间备注
冒泡O(n^2)O(n^2)稳定O(1)当n小时较好
交换O(n^2)O(n^2)不稳定O(1)当n小时较好
选择O(n^2)O(n^2)不稳定O(1)当n小时较好
插入O(n^2)O(n^2)稳定O(1)当大部分已经排序时较好
基数在这里插入图片描述在这里插入图片描述稳定O(n)B是真数(0–9) R是基数(个十百)
ShellO(n log n)O(n^s) 1<s<2不稳定O(1)s是所选分组
快速O(n log n)O(n^2)不稳定O(n log n)当n大时较好
归并O(n log n)O(n log n)稳定O(1)当n大时较好
堆O(n log n)O(n log n)不稳定O(1)当n大时较好

三、算法的空间复杂度

  1. 一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它是问题规模n的函数
  2. 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时将占用较多的存储单元，例如快速排序和归并排序
  3. 做算法分析时，主要讨论时间复杂度。从用户体验上看，更看重程序执行的速度。例如一些缓存产品和算法(基数排序)本质就是用空间换时间

四、冒泡排序

1. 概述

冒泡排序(Bubble Sorting)的基本思想是：通过对待排序序列从前向后(从下标较小的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部。
在这里插入图片描述

总结：

  • 一共进行数组大小减一次大的循环
  • 每一趟的排序次数在逐渐减少
  • 如果发现在某趟排序中没有发生一次交换则可以结束排序

2. 代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/1 12:19
 **/
public class BubbleSort {
    public static void main(String[] args) {
        int [] arr={3,9,-1,10,-1};
        boolean flag=true;
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i; j++) {
                if(arr[j]>arr[j+1]){
                    flag=false;
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
            if(flag){
                break;
            }else{
                flag=true;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

五、选择排序

1. 概述

选择排序(select sorting)也是一种简单的排序方法。它的基本思想是：第一次从arr[0]arr[n-1]中选择最小值，与arr[0]进行交换；第二次从arr[1]arr[n-1]中选取最小值，与arr[2]交换，……第i次从arr[i-1]arr[n-1]中选取最小值，与arr[i-1]交换，……第n-1次从arr[n-1]arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列

2. 代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/1 14:02
 **/
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {47, 24, 10, 9};
        System.out.println("排序前：" + Arrays.toString(arr));
        selectSort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    /**
     * 选择排序
     *
     * @param arr
     */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = arr[i];
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < min) {
                    minIndex = j;
                    min = arr[j];
                }
            }
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }
}

六、插入排序

1. 概述

插入排序(Insertion Sorting)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只有一个元素，无序表中有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表的元素的排序码进行比较，将它插入到有序表的适当位置，使之成为新的有序表

在这里插入图片描述

2. 代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/1 16:27
 **/
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        System.out.println("排序前：" + Arrays.toString(arr));
        insertSort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }
    /**
     * 插入排序
     * @param arr
     */
    public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int insertVal = arr[i];
            //要找的位置
            int insertIndex = i - 1;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            if(insertIndex+1!=i){
                arr[insertIndex + 1] = insertVal;
            }
        }
    }
}

七、希尔排序

1. 概述

希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序改进后的一种更高效的版本，也称为缩小增量排序

基本思想：

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分为一组，算法便终止

在这里插入图片描述

2. 代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/2 19:30
 **/
public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
    }

    public static void shellSort(int[] arr) {
        int count = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            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;
                }
            }
            System.out.println("希尔排序第" + (++count) + "轮=" + Arrays.toString(arr));
        }
    }
}

八、快速排序

1. 概述

快速排序(Quicksort)是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成两部分，其中一部分的所有数据都比另外一部分的所以数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此将整个数据变成有序的

2. 代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/2 20:27
 **/
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {-9, 78, 0, 23, -567, 70};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 快速排序
     *
     * @param arr
     * @param left
     * @param right
     */
    public static void quickSort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(l + r) / 2];
        int temp = 0;
        while (l < r) {
            while (arr[l] < pivot) {
                l += 1;
            }
            while (arr[r] > pivot) {
                r -= 1;
            }
            if (l >= r) {
                break;
            }
            temp = arr[r];
            arr[r] = arr[l];
            arr[l] = temp;
            if (arr[l] == pivot) {
                r -= 1;
            }
            if (arr[r] == pivot) {
                l += 1;
            }
        }
        if (l == r) {
            l += 1;
            r -= 1;
        }
        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }//向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }
    }
}

九、归并排序

1. 概述

归并排序(MERGE-SORT)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer)策略，将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案修补在一起。
在这里插入图片描述

2，代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/3 11:16
 **/
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println("排序后" + Arrays.toString(arr));
    }

    /**
     * 归并排序
     *
     * @param arr
     * @param left
     * @param right
     * @param temp
     */
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            //向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);
        }
    }

    /**
     * 归并排序的合并方法
     *
     * @param arr   需要排序的数组
     * @param left  左边有序数列的初始索引
     * @param mid   中间索引
     * @param right 右边索引
     * @param temp  中转数组
     */
    public 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];
                t += 1;
                i += 1;
            } else {
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }
        //将左边剩余的元素进行拷贝
        while (i <= mid) {
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        //将右边剩余的元素进行拷贝
        while (j <= right) {
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }
        //将temp数组的元素拷贝到arr
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }
    }
}

十、基数排序

1. 概述

基数排序介绍(桶排序)：

  • 基数排序(bucket sort)属于“分配式排序”(distribution sort)，又称为“桶子法”或bin sort，它是通过键值的各个位的值将要排序的元素分配至某些“桶”中，达到排序的作用
  • 基数排序是属于稳定性的排序，基数排序法是效率高的稳定性排序法
  • 基数排序是桶排序法的扩展
  • 基数排序是1887年赫尔曼 何乐礼发明的。它将整数按照位数切割成不同的数字，然后按每个位数分别比较

基数排序基本思想：

  • 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后从低位开始，依次进行依次排序。这样从低位排序一直到最高位排序完成以后，数列就变成为一个有序数列
  • 图文解释：
    在这里插入图片描述

2. 代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/3 16:24
 **/
public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214};
        radixSort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    /**
     * 基数排序
     *
     * @param arr
     */
    public static void radixSort(int[] arr) {
        //得到数组中的最大位数
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //最大数的位数
        int maxLength = (max + "").length();
        for (int k = 0, n = 1; k < maxLength; k++, n *= 10) {
            //定义二维数组，每个一维数组表示一个桶
            int[][] bucket = new int[10][arr.length];
            //记录每个桶中实际放入的元素个数
            int[] bucketElementCounts = new int[10];
            for (int i = 0; i < arr.length; i++) {
                int digitOfElement = arr[i] / n % 10;
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];
                bucketElementCounts[digitOfElement]++;
            }
            //遍历每一个桶，将数据放入原数组
            int index = 0;
            for (int i = 0; i < bucket.length; i++) {
                //若桶中有数据我们才放入原数组
                if (bucketElementCounts[i] != 0) {
                    for (int j = 0; j < bucketElementCounts[i]; j++) {
                        arr[index++] = bucket[i][j];
                    }
                }
                bucketElementCounts[i] = 0;
            }
        }
    }
}

说明：

  • 基数排序是通过空间换时间，当有海量数据时可能出现OutOfMemoryError
  • 有负数的数组，不用基数排序进行排序

十一、堆排序

1. 概述

  1. 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好、平均时间复杂度均为O(logn)，它也是不稳定排序

  2. 堆是具有以下性质的完全二叉树：每个节点的值都大于或等于其左右节点的值，称为大顶堆，注意：没有要求左右孩子值的大小关系

  3. 每个节点的值都小于或等于其左右孩子的值，称为小顶堆

  4. 大顶堆举例：
    在这里插入图片描述

  5. 一般升序采用大顶堆，降序采用小顶堆

2. 堆排序的基本思想

  1. 将待排序序列构造称为一个大顶堆
  2. 此时，整个序列的最大值就是堆顶的根节点
  3. 将其与末尾元素进行交换，此时末尾就是最大值
  4. 然后将剩余n-1个元素重新构造成为一个堆，这样会得到n个元素的次小值，如此反复则可得到一个有序序列

3. 代码演示

import java.util.Arrays;

/**
 * @author DELL
 * @Date 2020/2/8 11:50
 **/
public class HeapSort {
    public static void main(String[] args) {
        int arr[] = {4, 6, 8, 5, 9};
        heapSort(arr);
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    public static void heapSort(int[] arr) {
        int temp = 0;
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }
        for (int i = arr.length - 1; i > 0; i--) {
            temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, i);
        }
    }

    /**
     * @param arr    要调整的数组
     * @param i      表示非叶子节点在数组中的索引
     * @param length 表示对多少个元素进行调整
     */
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                k++;
            }
            if (arr[k] > temp) {
                arr[i] = arr[k];
                i = k;
            } else {
                break;
            }
        }
        arr[i] = temp;
    }
}
ysw！不将就
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
详解Java常用排序算法（10种，含演示动画）
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 1万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
java实现七种经典排序算法
诸葛浪
07-29 3844
七种常见排序算法java代码及图示，所有代码均可单独独立运行
十大经典排序算法——java语言
weixin_56781779的博客
11-11 5668
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
Java常用实现八种排序算法与代码实现
热门推荐
java_atguigu的博客
04-02 1万+
一、交换排序 所谓交换，就是序列中任意两个元素进行比较，根据比较结果来交换各自在序列中的位置，以此达到排序的目的。 1. 冒泡排序 冒泡排序是一种简单的交换排序算法，以升序排序为例，其核心思想是： 从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。 轮到下一组相邻元素，执行同样的比较操作，再找下一组，直到没有相邻元素可比较为止，此时最后的元素应是最大的数。 除了每次排序得到的最后一个元素，对剩余元素重复以上步骤，直到没有任何一对元素需要比较为止。
Java常见排序算法
Meng
07-10 2311
目录1、归并排序2、堆排序3、基数排序4、冒泡排序5、希尔排序6、快速排序7、插入排序8、选择排序1、基本思想归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。2、代码实现1、基本思想堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(
java 排序算法
01-11
代码中列举了java常见的排序算法，并备有简单的注释信息，对于初级开发人员可供参考。
Java排序算法总结之堆排序
09-03
主要介绍了Java排序算法总结之堆排序,详细分析了堆排序的原理与java实现技巧,需要的朋友可以参考下
Java排序算法实现：冒泡与选择排序示例代码
01-04
Java排序算法实现资源 这个资源是关于Java中排序算法实现的简单示例。排序算法是计算机科学中的基础概念，用于按升序或降序排列数据集。这里提供了两种常见的排序算法实现：冒泡排序和选择排序。 冒泡排序（Bubble ...
Java排序算法汇总大全.doc
09-21
想要获得高薪offer？内卷太严重？担心被裁员？总是忙于业务开发？只会CRUD？ 您需要充充电了大哥！只要自己足够强大，内功足够扎实，就不用担心这些...Java排序算法是基础中的基础，这都不会还能做好开发？赶紧上车！
JAVA排序算法收集处
04-22
这里包含了使用java语言的几大排序算法包括：插入排序、冒泡排序、归并排序、基数排序、希尔排序、快速排序、基数排序、选择排序。 jdk版本1.8 打开方式：解压后打开eclipse直接导入项目即可查看和运行代码。方便...
Java排序算法总结之归并排序
09-03
主要介绍了Java排序算法总结之归并排序,较为详细的分析了归并排序的原理与java实现技巧,需要的朋友可以参考下
Java 排序算法知识点总结.zip
最新发布
01-14
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
Java排序算法总结之冒泡排序
09-03
主要介绍了Java排序算法总结之冒泡排序,较为详细的分析了冒泡排序的原理与java实现技巧,需要的朋友可以参考下
Java语言实现常用的十种排序算法
Young_深情不及里子的博客
02-23 2155
排序问题一直都是程序工作或面试中的重点，特别是对于排序算法而言，在一些公司的笔试中，手写个冒泡啥的也不足为奇，因此今天抽空整理一下Java语言实现的各类排序算法，互勉学习一下。
java7种排序（需熟练掌握）
qq_53280986的博客
10-24 2132
java7种排序算法 文章目录java7种排序算法@[toc]1.冒泡排序2.插入排序3.选择排序4.希尔排序5.归并排序6.快速排序7.基数排序（基于桶排序） 1.冒泡排序 public void bubbleSort(int[] array){ for (int i = 0; i < array.length-1; i++) { boolean flag=false; for (int j = 0; j <array.lengt
十大排序算法（Java实现）
ji_meng的博客
06-27 2520
1.冒泡排序 2.快速排序
用 Java 实现的八种常用排序算法
低吟不作语的博客
10-13 1万+
八种排序算法可以按照如图分类 交换排序 所谓交换，就是序列中任意两个元素进行比较，根据比较结果来交换各自在序列中的位置，以此达到排序的目的。 1. 冒泡排序 冒泡排序是一种简单的交换排序算法，以升序排序为例，其核心思想是： 从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。 轮到下一组相邻元素，执行同样的比较操作，再找下一组，直到没有相邻元素可比较为止，此时最后的元素应是最大的数。 除了每次排序得到的最后一个元素，对剩余元素重复以上步骤，直到没有任何一对元素需要比较为止。 ..
java 排序算法
08-27
Java中常用的排序算法有很多种，以下是一些常见的排序算法： 1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果顺序错误就交换位置，重复这个过程直到所有元素都排好序。时间复杂度为O(n^2)。 2. 选择排序（Selection Sort）：每次从未排序部分选择最小（或最大）的元素放到已排序部分的末尾，重复这个过程直到所有元素都排好序。时间复杂度为O(n^2)。 3. 插入排序（Insertion Sort）：将数组分为已排序和未排序两个部分，每次从未排序部分选择一个元素插入到已排序部分的合适位置，重复这个过程直到所有元素都排好序。时间复杂度为O(n^2)。 4. 快速排序（Quick Sort）：选择一个基准元素，将小于基准的元素放在左边，大于基准的元素放在右边，然后对左右两个子数组递归地进行快速排序。时间复杂度平均为O(nlogn)，最坏情况下为O(n^2)。 5. 归并排序（Merge Sort）：将数组递归地拆分成两个子数组，分别对子数组进行归并排序，然后将两个有序子数组合并成一个有序数组。时间复杂度为O(nlogn)。 6. 堆排序（Heap Sort）：通过构建一个最大堆（或最小堆），然后将堆顶元素与最后一个元素交换，重复这个过程直到所有元素都排好序。时间复杂度为O(nlogn)。 以上只是一些常见的排序算法，每种算法都有其优缺点和适用场景，具体选择哪种排序算法要根据实际情况来决定。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ysw！不将就

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

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

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

打赏作者

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

抵扣说明：

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

余额充值