排序算法复杂度

排序算法的时间复杂度 链接:直接插入排序的平均时间复杂度为( )。__牛客网 来源:牛客网 一、时间复杂度: (1)定义: 时间复杂度是用来定性描述算法执行所需要的时间。现假设问题规模为n,解决该问题的算法中基本操作重复执行的次数是T(n)。如果有一个辅助函数f(n)使得T(n)/f(n)的极限值为不等于零的常数,则称f(n)是T(n)的同数量级函数,因此有T(n)=O(f(n)),此时O(f(n))称为算法的渐进时间复杂度,简称时间复杂度。时间复杂度越高,算法的执行效率越低。 (2)计算方法: 1)首先找... 阅读详情


请添加图片描述

选择排序

直接选择排序

时间复杂度O(n^2)
空间复杂度O(1)
稳定

    final static class selectSort{
        public selectSort(int[] arr){
            Sort(arr, arr.length);
        }

        private void Sort(int[] arr, int n) {
            for (int i = 0; i < n; i++) {
                int min = i;
                for (int j = i; j < n; j++) {
                    if(arr[min] > arr[j]){
                        min = j;
                    }
                }
                swap(arr, i, min);
            }
        }
    }

堆排序

时间复杂度不太好算啊,看看这个:https://blog.youkuaiyun.com/YuZhiHui_No1/article/details/44258297
建堆时间复杂度O(n)
堆排序时间复杂度O(nlogn)
空间复杂度O(1)

    final static class heapSort{
        //堆排序用new PriorityQueue<Integer>((o1, o2)->(o1 - o2));
        //https://www.runoob.com/w3cnote/heap-sort.html
        //https://zhuanlan.zhihu.com/p/45725214
        public heapSort(int[] arr){
            if(arr.length < 2) return;
            int len = arr.length;
            BuildMaxHeap(arr, len);
            for(int i=len-1; i>0; i--){
                swap(arr, 0, i);
                len--;
                heapify(arr, 0, len);
            }
        }
        public void BuildMaxHeap(int[] arr, int len){
            for(int i=(int) Math.floor(len / 2); i>=0; i--){
                heapify(arr, i, len);
            }
        }
        public void heapify(int[] arr, int i, int len){
            int left = i * 2 + 1;
            int right = i * 2 + 2;
            int larger = i;
            if(left < len && arr[left] > arr[larger]){
                larger = left;
            }
            if(right < len && arr[right] > arr[larger]){
                larger = right;
            }
            if(larger != i){
                swap(arr, i, larger);
                //交换之后larger位置为较小的值,继续向下调整
                heapify(arr, larger, len);
            }
        }
    }

插入排序

直接插入排序

时间复杂度O(n^2)
空间复杂度O(1)
稳定

    final static class insertSort{
        public insertSort(int[] arr){
            Sort(arr, arr.length);
        }

        private void Sort(int[] arr, int n) {
            for (int i = 1; i < n; i++) {
                int tmp = arr[i];
                int j = i - 1;
                while (j >= 0 && arr[j] > tmp) {
                    arr[j+1] = arr[j];
                    j--;
                }
                arr[j+1] = tmp;
            }
        }
    }

希尔排序

插入排序的改良,增加了步长
时间复杂度O(nlogn)
空间复杂度O(1)

    final static class shellSort{
        shellSort(int[] arr){
            Sort(arr, arr.length);
        }

        private void Sort(int[] arr, int n) {
            int gap = n;
            do{
                gap = gap / 3 + 1;
                for (int i = gap; i < n; i++) {
                    int tmp = arr[i];
                    int j = i - gap;
                    while (j >= 0 && arr[j] > tmp) {
                        arr[j + gap] = arr[j];
                        j -= gap;
                    }
                    arr[j + gap] = tmp;
                }
            }while (gap > 1);
        }
    }

交换排序

冒泡排序

时间复杂度O(n^2)
空间复杂度O(1)
稳定

    final static class BubbleSort{
        public BubbleSort(int[] arr){
            Sort(arr, arr.length);
        }

        private void Sort(int[] arr, int n) {
            for (int i = 0; i < n; i++) {
                for (int j = 1; j < n - i; j++) {
                    if(arr[j-1] > arr[j]){
                        swap(arr, j-1, j);
                    }
                }
            }
        }
    }

快速排序

时间复杂度O(nlogn)
最坏时间复杂度O(n^2) 当划分产生的两个子问题分别包含 n-1 和 0 个元素时,最坏情况发生。
空间复杂度O(logn) 其中sort递归调用生成partitionIndex

    final static class quickSort{
        public quickSort(int[] arr){
            Sort(arr, 0, arr.length-1);
        }
        public void Sort(int[] arr, int l, int r){
            if(l < r){
                int partitionIndex = partition(arr, l, r);
                Sort(arr, l, partitionIndex-1);
                Sort(arr, partitionIndex+1, r);
            }
        }
        public int partition(int[] arr, int l, int r){
            int pivot = l;
            int index = pivot + 1;
            for(int i=index; i<=r; i++){
                if(arr[i] < arr[pivot]){
                    swap(arr, i, index++);
                }
            }
            swap(arr, pivot, index-1);
            return index-1;
        }
    }

归并排序

时间复杂度O(nlogn)
空间复杂度O(n)
这个稍微想一下就行了,不是特别难

    final static class mergeSort{
        public mergeSort(int[] arr) {
            Sort(arr, 0, arr.length - 1);
        }
        public void Sort(int[] arr, int l, int r){
            if(l < r){
                int mid = (l + r)/2;
                Sort(arr, l, mid);
                Sort(arr, mid+1, r);
                merge(arr, l, mid, r);
            }
        }
        public void merge(int[] arr, int l, int mid, int r){
            int[] help = new int[r-l+1];
            int count = 0;
            int p = l, q = mid + 1;
            while(p <= mid && q <= r){
                help[count++] = arr[p] < arr[q] ? arr[p++] : arr[q++];
            }
            while(p <= mid){
                help[count++] = arr[p++];
            }
            while(q <= r){
                help[count++] = arr[q++];
            }
            for(int i = 0; i < help.length; i++){
                arr[l + i] = help[i];
            }
        }
    }

桶排序

计数排序

计数排序有点坑啊
他先找到数组中最大和最小值,然后用这个二者的差值作为计数数组的长度
如果我数组中就三个元素[1, 2, 100]就不合适了
时间复杂度O(n + k)
空间复杂度O(n + k)

    final static class countSort{
        countSort(int[] arr){
            Sort(arr, arr.length);
        }

        private void Sort(int[] arr, int n) {
            int max = arr[0];
            int min = arr[0];
            for (int i = 0; i < n; i++) {
                if (max < arr[i]) {
                    max = arr[i];
                }
                if (min > arr[i]) {
                    min = arr[i];
                }
            }
            // 最大最小元素之间范围[min, max]的长度
            int offset = max - min + 1;
            // 1. 计算频率,在需要的数组长度上额外加1
            int[] count = new int[offset + 1];
            for (int i = 0; i < n; i++) {
                // 使用加1后的索引,有重复的该位置就自增
                count[arr[i] - min + 1]++;
            }
            // 2. 频率 -> 元素的开始索引
            for (int i = 0; i < offset; i++) {
                count[i + 1] += count[i];
            }

            // 3. 元素按照开始索引分类,用到一个和待排数组一样大临时数组存放数据
            int[] aux = new int[n];
            for (int i = 0; i < n; i++) {
                // 填充一个数据后,自增,以便相同的数据可以填到下一个空位
                aux[count[arr[i] - min]++] = arr[i];
            }
            // 4. 数据回写
            for (int i = 0; i < n; i++) {
                arr[i] = aux[i];
            }
        }
    }

基数排序

我复制粘贴的,不太想看了
时间复杂度O(n * m)
空间复杂度O(m)

final static class RadixSort{
        public RadixSort(int[] arr) {
            // 对 arr 进行拷贝,不改变参数内容
            int[] array = Arrays.copyOf(arr, arr.length);

            int maxDigit = getMaxDigit(array);
            Sort(arr, maxDigit);
        }

        /**
         * 获取最高位数
         */
        private int getMaxDigit(int[] arr) {
            int maxValue = getMaxValue(arr);
            return getNumLenght(maxValue);
        }

        private int getMaxValue(int[] arr) {
            int maxValue = arr[0];
            for (int value : arr) {
                if (maxValue < value) {
                    maxValue = value;
                }
            }
            return maxValue;
        }

        protected int getNumLenght(long num) {
            if (num == 0) {
                return 1;
            }
            int lenght = 0;
            for (long temp = num; temp != 0; temp /= 10) {
                lenght++;
            }
            return lenght;
        }

        private int[] Sort(int[] arr, int maxDigit) {
            int mod = 10;
            int dev = 1;

            for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
                // 考虑负数的情况,这里扩展一倍队列数,其中 [0-9]对应负数,[10-19]对应正数 (bucket + 10)
                int[][] counter = new int[mod * 2][0];

                for (int j = 0; j < arr.length; j++) {
                    int bucket = ((arr[j] % mod) / dev) + mod;
                    counter[bucket] = arrayAppend(counter[bucket], arr[j]);
                }

                int pos = 0;
                for (int[] bucket : counter) {
                    for (int value : bucket) {
                        arr[pos++] = value;
                    }
                }
            }

            return arr;
        }

        /**
         * 自动扩容,并保存数据
         *
         * @param arr
         * @param value
         */
        private int[] arrayAppend(int[] arr, int value) {
            arr = Arrays.copyOf(arr, arr.length + 1);
            arr[arr.length - 1] = value;
            return arr;
        }
    }
    final static class mergeSort{
        public mergeSort(int[] arr) {
            Sort(arr, 0, arr.length - 1);
        }
        public void Sort(int[] arr, int l, int r){
            if(l < r){
                int mid = (l + r)/2;
                Sort(arr, l, mid);
                Sort(arr, mid+1, r);
                merge(arr, l, mid, r);
            }
        }
        public void merge(int[] arr, int l, int mid, int r){
            int []help = new int[r-l+1];
            int count = 0;
            int p = l, q = mid + 1;
            while(p<=mid && q<=r){
                help[count++] = arr[p] < arr[q] ? arr[p++] : arr[q++];
            }
            while(p<=mid){
                help[count++] = arr[p++];
            }
            while(q<=r){
                help[count++] = arr[q++];
            }
            for(int i=0; i<help.length; i++){
                arr[l+i] = help[i];
            }
        }
    }
排序算法复杂度对照表(含时间复杂度与空间复杂度) 下面给出的最优/平均/最差时间复杂度、额外空间复杂度,并在右侧给出简短说明(什么时候出现最优/最差或需要注意的地方)。所有复杂度以n为元素个数,k为键值范围,dL为关键字位数或字符串平均长度,M为内存缓冲能容纳的元素数,B为块大小(外存I/O 单位)。表格给出的是常见/典型实现的复杂度。备注:某些算法复杂度依赖实现细节(例如 Shell 的 gap 序列、Radix 的基数选择、外部排序的内存/磁盘参数等),表中注明“依赖”或给出常见情形。 阅读详情

相关推荐

深入解析常见排序算法的时间复杂度

本文还有配套的精品资源,点击获取 简介:排序算法是计算机科学中数据结构的基础,其效率由时间复杂度所衡量。本主题将比较选择排序、冒泡排序和递归排序这三种方法的时间复杂度,涵盖它们在不同情况下的性能表现,并讨论各自适用场景和优缺点。理解这些算法的时间复杂度有助于在实际应用中做出更合适的算法选择。 1. 排序算法与时间复杂度概念 在探索不同排序算法的世界之前,我们...

weixin_36304957的博客 1993

八种排序算法的时间复杂度复杂度

https://www.cnblogs.com/dll-ft/p/5861210.html 转载 1、稳定性 归并排序、冒泡排序、插入排序。基数排序是稳定的 选择排序、快速排序、希尔排序、堆排序是不稳定的   2、时间复杂度 最基础的四个算法:冒泡、选择、插入、快排中,快排的时间复杂度最小O(n*log2n),其他都是O(n2) 排序法 平均时间 最差情形 稳定度 ...

q2213065359的博客 16万+

pix4d安装步骤

pix4d三维模型软件的安装步骤

Little_Bee_27000的博客 1万+

常见的排序算法的时间复杂度

接着,对每个桶中的元素进行排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序),最后依次将各个桶中的元素取出,得到的就是有序序列。计数排序不是基于比较的排序算法,其优势在于在对一定范围内的整数排序时,复杂度为O(n+k),其中n为输入元素个数,k为待排序列中最大的数。例如,如果数据的范围非常大,或者数据的分布极不均匀,那么可能需要大量的桶,这可能导致空间复杂度的增加。基数排序的时间复杂度是线性的,为O(dn),其中d为数字的位数,n为待排序序列的长度。因此,时间复杂度为O(n^2)。

码字不易,大家的支持就是我坚持下去的动力 2万+

国家基因组科学数据中心(NGDC)---组学原始数据如何上传GSA

在发表文章之前我们需要将测序的原始数据上传到一个公共库,并在文中提供accession number,实现数据的公开共享,这是国际惯例。以前我们上传数据时只能上传到美国国立生物技术信息中心(NCBI)、欧洲生物信息学研究所(EBI)、日本核酸数据库(DDBJ),现在中国科学院北京基因组研究所(国家生物信息中心)国家基因组科学数据中心 (CNCB-NGDC)—中国的 "NCBI" 已经建立并日渐完善。组学原始数据归档库(GSA)是组学原始数据汇交、存储、管理与共享系统,是国内首个被国际期刊认可的组学数据发布平

sisichen 1万+

哨兵一号数据snap预处理_利用SNAP软件进行Sentinel-1A卫星微波影像的预处理

利用SNAP软件对雷达影像进行预处理,主要包括热噪声去除、轨道文件校正、辐射定标、滤波校正、多普勒地形校正,最终获得入射角和后向散射信息。数据:本次实验所用数据为哨兵一号(Sentinel-1A)干涉宽幅模式(Interferometric Wideswath,IW)下经过多视处理和地距转换的GRD格式产品一般处理流程如下:0 SNAP软件安装软件安装:安装成功后打开SNAP后如图所示:1 数据...

weixin_30000407的博客 1万+

排序算法的空间复杂度和时间复杂度

它是这样的一种排序算法,对于每一位使用稳定的排序算法来排序,常见的是使用计数排序或桶排序。例如,如果我们考虑一个国家,它的手机号码是10位数的,那么我们可以认为 k 是常数,即 k = 10。基数排序的时间复杂度通常表示为 O(kN),其中 N 是排序元素的个数(在这个例子中是手机号码的个数),k 是元素的统计特性,通常取决于这些元素的最大位数。然而,实际的时间复杂度还受到其他因素的影响,比如使用的稳定排序算法的复杂度、手机号码的分布情况、以及在实际操作中对桶(或计数数组)的处理效率等。

Sword52888的博客 1万+

基于ESP32-P4的低成本旋转式激光雷达系统设计

激光雷达(LiDAR)作为机器人环境感知的核心传感器,其本质是融合光学测距、机电控制与实时数据处理的嵌入式系统。理解时间飞行(ToF)原理与机械旋转耦合机制,是实现高精度点云采集的基础;而系统级误差源——如计时抖动、电机惯性、信号串扰和温漂——直接决定实际建图鲁棒性。在资源受限场景下,选用RISC-V双核MCU(如ESP32-P4)可兼顾实时控制与网络服务能力,通过硬件时间戳捕获、S型加减速轨迹规划、旋转变压器供电及双Bank OTA等工程手段,有效平衡分辨率、帧率与稳定性。本文围绕360°旋转式激光雷达的

weixin_36231030的博客 435

排序算法 时间复杂度、空间复杂度

介绍了各种排序算法的时间复杂度、空间复杂度

wechatonly的博客 2829

别再死磕NFP了!用Python+遗传算法搞定异形件自动排版(附完整代码)

本文介绍了如何利用Python和遗传算法实现异形件智能排版,解决传统NFP方法计算复杂的问题。通过Shapely库处理几何运算和DEAP库搭建遗传算法框架,结合模拟退火策略避免局部最优,显著提升材料利用率。附完整代码和优化技巧,适用于服装裁剪、金属加工等行业。

weixin_26965807的博客 236

常用排序算法复杂度分析

1、排序大类 排序算法大致可以分为两大类:内部排序和外部排序。内部排序指的是排序数据都存储在内存中。外部排序则需要借助到外出。常用排序算法都为内部排序。 2、内部排序分类 (1)插入排序:直接插入排序、二分法插入排序、希尔排序 (2)选择排序:直接选择排序、堆排序 (3)交换排序:冒泡排序、快速排序 (4)归并排序 (5)基数排序 3、各排序算法分析 3.1 插入排序 思想:每步将一个待排序的记录,按其数值大小插入到前面已经排好序的序列的合适位置,直到全部插入排序完为止。 关键问题:在前面已经排好序的

Blog of Jatsby 3649

网页内容抓取的艺术:使用R语言解析动态网页

本文探讨了使用R语言处理动态网页数据的方法。针对AJAX加载的学术网站,传统的静态抓取和RSelenium方法存在会话终止、浏览器错误等问题。通过分析发现内容通过admin-ajax.php加载,提出使用httr2模拟POST请求获取数据,配合rvest解析HTML内容。该方法避免了浏览器自动化的弊端,实现了高效稳定的动态内容提取,为处理类似AJAX网站提供了通用解决方案。

m0_74337424的博客 56

排序算法与复杂度介绍

基本介绍1、类似于时间复杂度的讨论,一个算法的空间复杂度(space complexity) 定义为该算法所耗费的存储空间,它也是问题规模n的函数。2、空间复杂度(space complexity) 是对一个算法在运行过程中临时占用存储空间大小的度量。有的算法需要占用的临时工作单元数与解决问题的规模n有关,它随着n的增大而增大,当n较大时,将占用较多的存储单元,例如快速排序和归并排序算法就属于这种情况。3、在做算法分析时,主要讨论的是时间复杂度。从用户体验上看,更看重程序运行的速度。

weixin_45942515的博客 1269

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

时间复杂度为on的排序算法_排序算法复杂度

一、排序算法的分类非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序。线性时间非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序。 二、排序算法的复杂度为了方便记忆,给出一些记忆规律。时间复杂度选择排序:都是 堆排序、归并排序:都是 计数排序:都...

weixin_29944883的博客 2951

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

常用的排序算法的时间复杂度和空间复杂度

常用的排序算法的时间复杂度和空间复杂度排序法 最差时间分析平均时间复杂度 稳定度 空间复杂度 冒泡排序O(n2)O(n2) 稳定 O(1) 快速排序O(n2)O(n*log2n) 不稳定 O(log2n)~O(n) 选择排序O(n2)O(n2) 稳定 O(1) 二叉树排序O(n2)O(n*log2n) 不一顶 O(n) 插入排序 O(n2)O(n2) 稳定 O(1) 堆排序O(n*log2n) O(n*log2n) 不稳定 O(1) 希尔排序OO 不稳定 O(1)1、时间复杂度 (1)时间频度 一个算法执行

小小外星人的技术博客 20万+

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

常用排序算法的时间复杂度和空间复杂度

常用的排序算法的时间复杂度和空间复杂度 排序法 最差时间分析 平均时间复杂度 稳定度 空间复杂度 冒泡排序 O(n2) O(n2) 稳定 O(1) 快速排序 O(n2) O(nlog2n) 不稳定 O(log2n)~O(n) 选择排序 O(n2)

weixin_49307896的博客 2950

常见的几种排序算法的时间复杂度

一. 排序算法的介绍 概述:排序也称排序算法,排序是将一组数据,依指定的顺序进行排列的过程。 排序的分类 (1) 内部排序:指将需要处理的所有数据都加载到内部存储器中进行排序。 (2) 外部排序:数据量过大,无法全部加载到内存中,需要借助外部存储进行排序。 二. 时间复杂度的相关概念 度量一个程序(算法)执行时间的两种方法。 (1) 事后统计的方法 (2) 事前估算的方法 时间频度的介绍。 时间频度:一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。

s19862388581的博客 8173

常用的排序算法的时间复杂度

常用的排序算法的时间复杂度

weixin_63791423的博客 1260

常见排序算法及复杂度分析

基数排序 | O(d(n+k)) | O(d(n+k)) | O(d(n+k)) | O(n+k) | 稳定 || 计数排序 | O(n+k) | O(n+k) | O(n+k) | O(k) | 稳定 || 选择排序 | O(n²) | O(n²) | O(n²) | O(1) | 不稳定 || 冒泡排序 | O(n²) | O(n) | O(n²) | O(1) | 稳定 || 插入排序 | O(n²) | O(n) | O(n²) | O(1) | 稳定 |

weixin_73861555的博客 1174

排序算法基础:时间复杂度与空间复杂度

排序也被称为排序算法,排序是将一组数据,依照指定的顺序进行排列的过程。 排序的分类: 内部排序: 指将需要处理的所有数据都加载到内部存储器中进行排序。 2)外部排序法: 数据量过大,无法全部加载到内存中,需要借助外部存储进行排序。 常见的排序算法分类图示: 算法的时间复杂度 度量一个程序执行时间的两种方法 1)事后统计的方法 这种方法可行,但是有两个问题:一是要想对设计的算法的运行性能进行评测,需要实际运行该程序;二是所得时间的统计量依赖于计算机的硬件、软件等环境因素,这种方式,要在同一台计算机的相同状

我不想学习但是必须学习 387

八种经典排序算法复杂度

一、时间复杂度 1、时间复杂度为O(n*n)的排序 冒泡排序,选择排序、插入排序(常量系数较低) 2、时间复杂度为O(n*logn)的排序 归并、快速(只是因为系数较低)、堆、希尔 3、时间复杂度为O(n)的排序: 基数排序、计数排序 二、空间复杂度 1、空间复杂度为O(1)的排序: 冒泡排序,选择排序、插入排序、堆排序、希尔排序 2、空间复杂度为O(l

zdy_lsh的博客 6885

排序算法分类 排序算法时间复杂度、空间复杂度、稳定性

排序算法比较表格 1 归并排序可以通过手摇算法将空间复杂度降到O(1),但是时间复杂度会提高。 2 基数排序时间复杂度为O(N*M),其中N为数据个数,M为数据位数。 辅助记忆 时间复杂度记忆- 冒泡、选择、直接 排序需要两个for循环,每次只关注一个元素,平均时间复杂度为O(n2)(一遍找元素O(n),一遍找位置O(n)) 快速、归并、希尔、堆基于二分思想,log...

weixin_40294256的博客 797
上一篇: netty源码分析channel初始msg
下一篇: 自学白帽子黑客第三年总结
小健健健
博客等级 码龄8年 101粉丝 68原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值