【第一课】保姆级教学,带你玩转时间复杂度和空间复杂度。

VMware Converter 6.2.0保姆级教程:从物理机到ESXi主机的完整迁移指南(含常见错误排查) 本文提供VMware Converter 6.2.0从物理机迁移至ESXi主机的完整保姆级教程。详细解析了迁移前的环境规划、核心转换过程步骤、版本差异对比,并重点针对代理安装失败、任务卡顿、虚拟机无法启动等常见错误提供了实战排查与解决方案,确保P2V迁移顺利进行。 阅读详情

大家好呀,我是蛋蛋。

数据结构与算法,作为编程界从入门到劝退的王者,是很多初学者心中神圣而想侵犯的村花儿,化身舔狗,费尽心思,舔到最后,我命油我不油天。

35a9394dd60d05da105409af7cf006f

作为一名大学之前编程能力为零,以为计算机专业就是打游戏的咸鱼,到参加 ACM 竞赛,靠着划水和抱大腿拿了几块金银铜铁牌的前 ACM 混子选手,想起之前疯狂跪舔数据结构和算法的日子,至今我扔能掬出一把辛酸泪。

a473e05ff3b1e343a3e8be3c0f8330d

为了让臭宝们不再像我这样当个人这么难,我决定和大家一起学习数据结构与算法,我希望能用傻瓜的方式,由浅入深,从概念到实践,一步一步的来,这个过程可能会很长,我希望在这个过程中你能喜欢上它,能发现它们冰冷外表下有趣的灵魂。


​ 330270bf82decb82b96474e862ca67f

复杂度分析主要就是时间复杂度和空间复杂度,接下来的文章也主要围绕这两方面来讲。废话不多说,前排马扎瓜子准备好,蛋蛋小课堂正式接客。

3c8b4b4b347be28e6e7ba920da4ac28

复杂度分析

刚刚我说过,在本蛋看来,复杂度分析是数据结构和算法中最重要的知识点,毫不夸张的说,这就是数据结构与算法学习的核心所在。你学会了它你就入的了门,你学不会它,你就永远不知道门儿在哪。

为什么复杂度分析会这么重要?

这个就要从盘古开天辟地,呃,从数据结构与算法的本身说起。

841e629526bad79da1f261ef22f57e4

我平常白天做梦的时候,总是想着当当咸鱼划划水就能赚大钱,最好就是能躺着,钱就直接砸到我脑阔上。数据结构与算法虽然没有本蛋这么大的梦想,但是它的出现也是想着花更少的时间和更少的存储来解决问题。

那如何去考量“更少的时间和更少的存储”,复杂度分析为此而生。

蛋蛋:所以为什么复杂度分析重要你们知道了叭?

臭宝:不知道不知道

蛋蛋:啥?还不知道???

臭宝:对呀对呀

蛋蛋:。。。

既然你诚心诚意的不知道,那我就大发慈悲的打个不恰当的比方。

如果把数据结构与算法看成武功招式,那复杂度分析就是对应的心法。

如果只是学会了数据结构与算法的用法,不学复杂度分析,这就和你费尽千辛万苦在隔壁老王家次卧进门右手第二块地砖下偷挖出老王打遍村里无敌手的村林至宝王霸拳,然后发现秘籍上只有招式,没有内功心法,好好得王霸拳变的还不如王八拳。只有学会了王霸之气,才能虎躯一震,王霸之气一噗,震走村口光棍李养的哈巴狗。

e243977cfd3ab4e0a24d432bad980f9

臭宝:哇,厉害厉害厉害,你胖你说的都对,但还是没必要学啊。

蛋蛋:???

臭宝:现在有很多工具啊包啊,代码随便跑一下,就能轻轻松松知道运行了多少时间占了多少内存啊。算法的效率不就轻松比对出来了么?

蛋蛋:。。。

吐样吐森破!吃葡萄不吐葡萄皮!

你们说的这种主流叫做事后统计法。

简单来说,就是你需要提前写好算法代码和编好测试数据,然后在计算机上跑,通过最后得出的运行时间判断算法时效的高低,这里的运行时间就是我们日常的时间。

a3ad51bbbfe89094c390dcefca98bcf

我且不用“万一你费劲心思写好的算法代码本身是个很糟糕的解法”这种理由去反驳你,事后统计法本身存在很多缺陷,它并不是一个对我们来说有用的度量指标:

首先,事后统计法太依赖计算机的软件和硬件等性能。代码在 core i7 处理器的就比 core i5 处理器的运算速度快,更不用说不同的操作系统、不同的编程语言等软件方面,就算是在同一台电脑上,用的所有的东西都一样,内存的占用或者是 CPU 的使用率也会造成运行时间的差异。

再者,事后统计法太依赖于测试数据集的规模。同样是排序算法,你随便整 5 个 10 个的数排序,就算最垃圾的排序算法,也看起来快的和法拉利一样,如果是来10w 个 100w 个,那不同的算法的差距就很大了,而且同样是 10w 个 100w 个数,顺序和乱序的时间又不同了。

那么问题来了,到底测试数据集选多少个合适?数据的顺序如何定又算合适?

说不出来了叭?

9671fb039a9fd6df3d2b09de638a558

可以看出,我们需要一个不依赖于性能和规模等外力影响就可以估算算法效率、判断算法优劣的度量指标,而复杂度分析天生就是干这个的,这也是为什么我们要学习并必须学会复杂度分析!

时间复杂度

时间复杂度,也就是指算法的运行时间。

对于某一问题的不同解决算法,运行时间越短算法效率越高,相反,运行时间越长,算法效率越低。

那么如何估算时间复杂度呢?

大佬们在拽掉脑阔上最后一根头发的时候发现,当用运行时间去描述一个算法快慢的时候,算法中执行的总步数显得尤为重要。

因为只是估算,我们可以假设每一行代码的运行时间都为一个 Btime,那么算法的总的运行时间 = 运行的总代码行数。

下面我们来看这么一段简单的代码。

def dogeggs_sum (n):
    sum = 0
    
    for dogegg in range(n):
        sum += dogegg
    return sum

在上面假设的情况下,这段求累加和的代码总的运行时间是多少呢?

第 2 行代码需要 1 Btime 的运行时间,第 4 和 第 5行分别运行了 n 次,所以每个需要 n * Btime 的运行时间,所以总的运行时间就是 (1 + 2n) * Btime。

我们一般用 T 函数来表示****赋值语句的总运行时间,所以上面总的运行时间就可以表达成 T(n) = (1 + 2n) * Btime,翻译一下就是“数据集大小为 n,总步数为 (1 + 2n) 的算法的执行时间为 T(n)”。

通过公式,我们可以看出 T(n) 和总步数是成正比关系,这个规律的发现其实是很重要的,因为这个告诉了我们一种趋势,数据集规模和运行时间之间有趋势!

所有人准备,我们很熟悉的大 O 闪亮登场了!

d5ccaa88645597b99e86b2f4123a953

大 O 表示法

大 O 表示法,表示的是算法有多快。

这个多快,不是说算法代码真正的运行时间,而是代表着一种趋势,一种随着数据集的规模增大,算法代码运行时间变化的一种趋势。一般记作 O(f(n))。

那么之前的公式就变成 T(n) = O(f(n)),其中 f(n) 是算法代码执行的总步数,也叫操作数。

a8e55e68c25472d332026054eab4376

n 作为数据集大小,它可以取 1,10,100,1000 或者更大更大更大的数,到这你就会发现一件很有意思的事儿,那就是当数据集越来越大时,你会发现代码中的某些部分“失效”了。

还是以之前的代码为例。当 n = 1000 时,1 + 2n = 2001,当 n = 10000 时,1 + 2n = 20001,当这个 n 持续增大时,常数 1 和系数 2 对于最后的结果越来越没存在感,即对趋势的变化影响不大。

所以对于我们这段代码样例,最终的 T(n) = O(n)。

接下来再用两段代码进一步学一下求时间复杂度分析。

时间复杂度分析

代码 1

def dogeggs_sum (n):
    sum = 0

    for dogegg in range(n):
        for i in range(n):
            sum += dogegg * i
    return sum

这段代码我会从最开始一点点带你来。

第 2 行需要运行 1 次 ,第 4 行需要运行 n 次,第 5 行和第 6 行分别需要运行 n² 次。所以总的运行次数 f(n) = 1 + n + 2n²。

当 n 为 5 的时候,f(n) = 1 + 5 + 2 * 25,当 n 为 10000 的时候,f(n) = 1 + 10000 + 2 * 100000000,当 n 更大呢?

这个时候其实很明显的就可以看出来 n² 起到了决定性的作用,像常数 1,一阶 n 和 系数 2 对最终的结果(即趋势)影响不大,所以我们可以把它们直接忽略掉,所以执行的总步数就可以看成是“主导”结果的那个,也就是 f(n) = n²。

自然代码的运行时间 T(n) = O(f(n)) = O(n²)。

代码 2

def dogeggs_sum (n):
    sum1 = 0
    for dogegg1 in range(n):
        sum1 += dogegg1

    sum2 = 0
    for dogegg2 in range(n):
        for i in range(n):
            sum2 += dogegg2 * i

    sum3 = 0
    for dogegg3 in range(n):
        for i in range(n):
            for j in range(n):
                sum3 += dogegg3 * i * j

    return sum1 + sum2 + sum3

上面这段代码是求三部分的和,经过之前的学习应该很容易知道,第一部分的时间复杂度是 O(n),第二部分的时间复杂度是 O(n²),第三部分是 O(n³)。

正常来讲,这段代码的 T(n) = O(n) + O(n²) + O(n³),按照我们取“主导”部分,显然前面两个小弟都应该直接 pass,最终 T(n) = O(n³)。

通过这几个例子,聪明的小婊贝们肯定会发现,对于时间复杂度分析来说,只要找起“主导”作用的部分代码即可,这个主导就是最高的那个复杂度,也就是执行次数最多的那部分 n 的量级。

剩下的就是多加练习,有意识的多去想多去练,就可以和我一样 帅气 稳啦。

eb4c23941d5a7f506df7199b0792e8a

常见时间复杂度

算法学习过程中,我们会遇到各种各样的时间复杂度,但纵使你代码七十二变,几乎也逃不过下面这几种常见的时间复杂度。

时间复杂度阶f(n) 举例
常数复杂度O(1)1
对数复杂度O(logn)logn + 1
线性复杂度O(n)n + 1
线性对数复杂度O(nlogn)nlogn + 1
k 次复杂度O(n²)、O(n³)、…n² + n +1
指数复杂度O(2n)2n + 1
阶乘复杂度O(n!)n! + 1

上表的时间复杂度由上往下依次增加,O(n) 和 O(n²) 前面已经讲过了,O(2n) 和 O(n!) 效率低到离谱,以后不幸碰到我再提一下,就不再赘述。

下面主要来看剩下几种最常见的时间复杂度。

O(1)

O(1) 是常数时间复杂度。

在这你要先明白一个概念,不是只执行 1 次的代码的时间复杂度记为 O(1),只要你是常数,像 O(2)、O(3) … O(100000) 在复杂度的表示上都是 O(1)。

n = 10000
res = n / 2 
print(res)

比如像上面这段代码,它运行了 3 次,但是它的时间复杂度记为 O(1),而不是 O(3)。

因为无论 n 等于多少,对于它们每行代码来说还是只是执行了一次,代码的执行时间不随 n 的变化而变化。

O(logn)

O(logn) 是对数时间复杂度。首先我们来看一段代码:

dogegg = 1

while dogegg < n:
    dogegg = dogegg * 2

根据之前讲的,我们先找“主导”,在这主导就是第 4 行代码,只要算出它的时间复杂度,总的时间复杂度就知道了。

其实很简单,上面的代码翻译一下就是初始化 dogegg = 1, 乘上多少个 2 以后会 ≥ n。

baa2ae991ecd8ee28c096a7158418e3

假设需要 x 个,那么相当于求:

c2a5b74ac6758928a953d695ef276ce

即:

426768f16b2624f36b2426a7fc29837

所以上述代码的时间复杂度应该为 O(log2n)。

但是对于对数复杂度来说,不管你是以 2、3 为底,还是以 10 为底,通通记作 O(logn),这是为什么呢?

这就要从对数的换底公式说起。

87196511cc38c4ce5a1b616cb79ab46

根据换底公式,log2n 可以写成:

c1ad669cd091db985564c170bbae212

对于时间复杂度来说:

9aeca2653fa3771e6d4145b07398cf7

所以在对数时间复杂度中我们就忽略了底,直接用 O(logn) 来表示对数时间复杂度。

O(nlogn)

O(nlogn),真的是很常见的时间复杂度,像后面会学到的快速排序、归并排序的时间复杂度都是 O(nlogn)。

如果只是简单看的话是在 logn 外面套了层 for 循环,比如像下面这段代码:

def stupid_cnt(n):
    cnt = 0
    for i in range(n):
        dogegg = 1

        while dogegg < n:
            dogegg = dogegg * 2
            cnt += 1
    return cnt

当然像上面这种 stupid 代码一般人不会写,我也只是举个例子给大家看,我是狗蛋,大家千万不要以为我是傻狗。

981494700979d1faa8e8c390762683b

最好情况、最坏情况和平均情况时间复杂度

除了数据集规模影响算法的运行时间外,“数据的具体情况”也会影响到运行时间。

我们来看这么一段代码:

def find_word(lst, word):

    flag = -1
    for i in range(len(lst)):
        if lst[i] == word:
            flag = i
            break

    return flag

上面这段简单代码是求变量 word 在列表 lst 中出现的位置,我用这段来解释“数据的具体情况”是什么意思。

变量 word 可能出现在列表 lst 的任意位置,假设 a = [‘a’, ‘b’, ‘c’, ‘d’]:

  • 当 word = ‘a’ 时,正好是列表 lst 的第 1 个,后面的不需要再遍历,那么本情况下的时间复杂度是 O(1)。
  • 当 word = ‘d’ 或者 word = ‘e’ 时,这两种情况是整个列表全部遍历完,那么这些情况下的时间复杂度是 O(n)。

这就是数据的具体情况不同,代码的时间复杂度不同。

根据不同情况,我们有了最好情况时间复杂度、最坏情况时间复杂度和平均情况时间复杂度这 3 个概念。

最好情况时间复杂度

最好情况就是在最理想的情况下,代码的时间复杂度。对应上例变量 word 正好是列表 lst 的第 1 个,这个时候对应的时间复杂度 O(1) 就是这段代码的最好情况时间复杂度。

最坏情况时间复杂度

最坏情况就是在最差的情况下,代码的时间复杂度。对应上例变量 word 正好是列表 lst 的最后一个,或者 word 不存在于列表 lst,这个时候对应的时间复杂度 O(n) 是这段代码的最坏情况时间复杂度。

平均情况时间复杂度

大多数情况下,代码的执行情况都是介于最好情况和最坏情况之间,所以又出现了平均情况时间复杂度。

那怎么计算平均时间复杂度呢?这个说起来有点复杂,需要用到概率论的知识。

在这里我还是用上面的例子来讲,因为只是简单的科普一下,为了方便计算,我假设的会有点随意:

  • 从大的方面来看,查找变量 x 在列表 lst 中的位置有两种情况:在或者不在。假设变量 x 在或者不在列表 lst 中的概率都为 1/2。
  • 如果 x 在列表 lst 中,那么 x 有 n 种情况,它可能出现在 0 到 n-1 中任意位置,假设出现在每个位置的概率都相同,都为 1/n。

每个出现的概率(即权重)知道了,所以平均时间复杂度为:

c73b893dd0a027c31b659555c019789

是不是看着有点眼熟,这就是我们都学过的加权平均值。

什么,没学过?问题不大。加权平均值就是将各数值乘以相应的权数,然后加总求和得到总体值,再除以总的单位数。

所以最终的平均时间复杂度就为:

a335eac2c3512962a06ab6325e4504b

臭宝:又是最好,又是最坏,又是平均的,这么多到底用哪个呀?

蛋蛋:这个还用问?当然是选择最坏情况时间复杂度啊!

最好情况,反应最理想的情况,怎么可能天上天天掉馅饼,没啥参考价值。

平均情况,这倒是能反映算法的全面情况,但是一般“全面”,就和什么都没说一样,也没啥参考价值。

最坏情况,干啥事情都要考虑最坏的结果,因为最坏的结果提供了一种保障,触底的保障,保障代码的运行时间这个就是最差的,不会有比它还差的。

所以,不需要纠结各种情况,算时间复杂度就算最坏的那个时间复杂度即可。

空间复杂度

空间复杂度相较于时间复杂度来说,比较简单,需要掌握的内容不多。

空间复杂度和时间复杂度一样,反映的也是一种趋势,只不过这种趋势是代码运行过程中临时变量占用的内存空间。

臭宝:为什么是“临时”咧?

蛋蛋:这就要从代码在计算机中的运行说起啦。

代码在计算机中的运行所占用的存储空间呐,主要分为 3 部分:

  • 代码本身所占用的
  • 输入数据所占用的
  • 临时变量所占用的

前面两个部分是本身就要占这些空间,与代码的性能无关,所以我们在衡量代码的空间复杂度的时候,只关心运行过程中临时占用的内存空间。

空间复杂度记作 S(n),表示形式与时间复杂度一致。

3f49fdacf9fcf8560613e0350e1f43d

在这同样 n 作为数据集大小,f(n) 指的是规模 n 所占存储空间的函数。

空间复杂度分析

下面我们用一段简单代码来学习下如何分析空间复杂度。

def dogeggs_sum(lst):
    sum = 0
    for i in range(len(lst)):
        sum += lst[i]

    return sum

上述代码是求列表 lst 的所有元素之和,根据之前说的,只计算临时变量所占用的内存空间。

形参 lst 所占的空间不计,那么剩下的临时变量只有 sum 和 i,sum 是存储和,是常数阶,i 是存储元素位置,也是常数阶,它俩所分配的空间和规模 n 都没有关系,所以整段代码的空间复杂度 S(n) = O(1)。

常见空间复杂度

常见的空间复杂度有 O(1)、O(n)、O(n²),O(1) 在上节讲了,还有就是像 O(logn) 这种也有,但是等闲不会碰到,在这里就不罗嗦了。

O(n)

def create_lst(n):
    lst = []
    for i in range(n):
        lst.append(i)

    return lst

上面这段傻傻的代码有两个临时变量 lst 和 i。

其中 lst 是被创建的一个空列表,这个列表占用的内存随着 for 循环的增加而增加,最大到 n,所以 lst 的空间复杂度为 O(n),i 是存储元素位置的常数阶,与规模 n 无关,所以这段代码最终的空间复杂度为 O(n)。

O(n²)

def create_lst(n):
    lst1 = []
    for i in range(n):
        lst2 = []
        for j in range(n):
            lst2.append(j)
        lst1.append(lst2)
    return lst1

还是一样的分析方式,很明显上面这段傻二次方的代码创建了一个二维数组 lst,一维 lst1 占用 n,二维 lst2 占用 n²,所以最终这段代码的空间复杂度为 O(n²)。


到这里,复杂度分析就全部讲完啦,只要臭宝们认真看完这篇文章,相信会对复杂度分析有个基本的认识。复杂度分析本身不难,只要多加练习,平时写代码的时候有意识的多想估算一下自己的代码,感觉就会慢慢来啦。

这是在 优快云 的第一篇,写完真心不太容易,希望开了个好头。码字不易,臭宝们多多支持呀,给我点赞呀。

我是蛋蛋,我们下次见~

6df0e1c0c99a1d202429b8776215f91
SAP Fiori Launchpad 上看不到任何 tile 应该怎么办? 中心UI组件是一个框架,为所有SAPFiori应用程序提供公共基础设施SAPFiorilaunchpad是所有SAPFioriUI的基础,并为SAPFiori应用程序提供基本功能,如登录,界面大小,应用程序之间的导航,和基于角色的应用程序目录。ABAP前端服务器包含所有基础设施组件,用于为客户端生成SAPFiori应用程序特定的UI,并与SAPBusinessSuite后端系统通信。SAPFiori应用程序的处理过程如下首先,客户端加载SAPFiori应用程序的界面。... 阅读详情

相关推荐

YOLOv11n-seg 实战指南:从训练到模型部署的完整流程

本文提供了YOLOv11n-seg实例分割模型从环境准备、数据标注到模型训练、验证及最终部署的完整实战指南。详细讲解了如何准备多边形掩码数据、配置关键训练参数、解读分割核心评估指标,并重点介绍了将模型导出为ONNX等格式进行部署的流程与优化技巧,帮助开发者高效完成从开发到生产的全链路实践。

weixin_29062255的博客 558

算法:关于最好、最坏、平均、均摊时间复杂度

最好、最坏情况时间复杂度 如下代码表示在一个无序的数组(array)中,查找变量x 出现的位置。如果没有找到,就返回 -1。 // n 表示数组 array 的长度 int find(int[] array, int n, int x) { int i = 0; int pos = -1; for (; i < n; ++i) { if (array[i] == x) pos = i; } return pos; } 这段代码的复杂度是O(n),其中n表示一个数组的长度。 我们在数组中

OceanStar的博客 3950

单片机技术入门与实战:从零基础到项目开发

单片机(MCU)作为嵌入式系统的核心组件,集成了CPU、内存和各种接口电路,广泛应用于智能家居、工业控制和汽车电子等领域。其工作原理基于实时控制和低功耗设计,通过定时器、中断系统和通信接口等功能模块实现各种控制任务。在物联网和智能硬件快速发展的背景下,掌握单片机开发技术成为电子工程师的重要技能。本文以STM32和PIC系列为例,详细解析单片机的基本概念、功能模块和选型指南,并分享从入门到项目实战的系统学习方法,帮助开发者在3-6个月内快速掌握这一关键技术。

weixin_35753291的博客 655

数据结构与算法——复杂度分析(二)

同一段代码,在不同输入的情况下,复杂度量级有可能是不一样的。最好情况时间复杂度最坏情况时间复杂度平均情况时间复杂度均摊时间复杂度同一段代码在不同情况下时间复杂度会出现量级差异,为了更全面,更准确的描述代码的时间复杂度,所以引入这4个概念。代码复杂度在不同情况下出现量级差别时才需要区别这四种复杂度。大多数情况下,是不需要区别分析它们的。其中,平均时间复杂度是代码在不同情况下复杂度出现了量级差别,用代码所有可能情况下爱执行次数的加权平均值表示。

技术知识分享 421

DPARSF高级版 vs 基础版怎么选?没有T1数据也能做fMRI分析吗?

本文深度对比了DPARSF高级版与基础版在fMRI分析中的核心差异与适用场景,特别针对无T1数据的情况提供了实战解决方案。高级版依赖T1像实现高精度配准,适合需要精确解剖定位的研究;基础版则无需T1数据,适用于功能连接等相对空间要求不高的分析。文章还提供了版本选择决策树和常见问题解决方案,帮助研究者根据实际需求做出最优选择。

weixin_42526087的博客 132

地下水环评(一级)实践技术及Modflow地下水数值模拟

涉及地下水流场绘制软件(Surfer)的操作流程及数据处理讲解、1.地下水环境影响评价基础:总则、影响识别、工作分级、技术要求、术语解析;2.地下水环境现状调查及影响预测:现场工作及实验方法,预测技术;实例讲解地下水环境影响评价的原则、内容、工作程序、方法。地下水环境影响评价实践技术应用与数值模拟。地下水一级、二级以及三级评价技术路线。1.地下水环评的资料需求及数据获取。真实地下水环评案例的建模流程演练。3. 地下水数值模拟的建模步骤。3. 解析法模拟的过程及处理。地下水二级及三级评价技术路线。...

zmjia111的博客 1428

数据结构与算法---最好和最坏情况时间复杂度分析

最好和最坏情况时间复杂度(best case time complexity) 案例代码如下: // n 表示数组 array 的长度 int find(int[] array, int n, int x) { int i = 0; int pos = -1; for (; i < n; ++i) { if (array[i] == x) pos = i; } return pos; } 上面代码非常的简单 ,在无序的数组里,找变量x出现的位置。没找到就返回-1。这段代码的时间复杂度是O

juejuehaoshuai的博客 2618

在 ABAP RAP 草稿模式中实现校验与 State Message:从业务规则到 Fiori 体验的全链路实践

本文深入探讨了SAP RAP框架中草稿业务对象的校验与消息机制,重点分析了validation、state message和transition message的应用场景及实现方法。文章指出,RAP校验机制可确保草稿数据的完整性,通过即时反馈防止错误数据进入激活态。同时详细比较了两类消息:state message(持久化)和transition message(临时性)的特点与适用场景。作者结合旅游预订案例,展示了如何在数据模型、行为定义和行为实现中配置校验规则,并给出工程实践中的常见误区与解决方案,如避

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 196

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

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

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

加密算法:深度解析Ed25519原理

在 Solana 开发过程中,我一直对 Ed25519 加密算法 如何生成公钥、签名以及验证签名的机制感到困惑。为了弄清这一点,我查阅了大量相关资料,终于对其流程有了更清晰的理解。在此记录实现过程,方便日后查阅。

盹猫的博客 1万+

Agent应用实践之三 - 基础:AgentScope-ReActAgent源码解析

本章通过总结AgentScope的核心类,再通过分析ReActAgent调用大模型的底层源码原理。使我们基本了解了Agent的基本原理,这个实现方式与OpenClaw使用pi-mono的Agent基础框架是一致的。了解完ReActAgent的基本原理,下一章我们会将一下SpringBoot集成方式的代码原理,这两章是我们构建后续内容的基本框架。

代码让AI扣 474

[ 数据结构 -- 手撕排序算法第五篇 ] 快速排序 非递归实现

手撕排序算法系列之第五篇:快速排序(下) 从本篇文章开始,我会介绍并分析常见的几种排序,大致包括直接插入排序,冒泡排序,希尔排序,选择排序,堆排序,快速排序,归并排序等。 大家可以点击此链接阅读其他排序算法:排序算法_大合集(data-structure_Sort) 快速排序的递归实现方法全部总结在这篇:快速排序 <包含hoare法,挖坑法,前后指针法> 及其算法优化 这篇文章我们将一起讨论快速排序的非递归实现方法~ 1.快排非递归的实现思想 快排的非递归实现方法是利用了栈(栈 S...

优快云博客 7601

拉曼光谱入门:5.表面增强与共振增强

拉曼散射效应因其弱信号特性限制了传统拉曼光谱术的检测灵敏度。为克服这一局限,表面增强拉曼光谱术(SERS)和共振增强拉曼光谱术(RRS)被开发出来,显著提升了信号强度。SERS通过金属表面的电磁和化学效应放大信号,而RRS则通过匹配激发光波长与分子电子跃迁波长来增强信号。这两种技术扩大了拉曼光谱的应用范围,尤其在低浓度和微量试样分析中表现出色,尽管在实验操作和试样损伤方面存在挑战。

qq_53529450的博客 1448

数据结构--1.时间复杂度和空间复杂度

保姆级教学!彻底学会时间复杂度和空间复杂度

weixin_42035282的博客 440

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

leetcode刷题时间空间复杂度

保姆级教学!彻底学会时间复杂度和空间复杂度

yan57628的博客 223

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

保姆级教学第三弹:插入排序及其优化

插入排序 核心思想:一个无序数组,将第一个数看做是有序的,将后面的数依次插入到前面有序数列,通过比较,插入到正确位置,从而形成新的有序数列。 从他的核心思想中,我们可以提取出两个点。一是:将后面看做无序的数列,依次插入前面,这是第一层外循环,控制插入多少次,也就是后面有多少个数;二是:插入的时候,与前面有序数列进行比较,插入到正确位置,这是第二次内循环,控制要比较多少次才能插入到正确位置,也就是有序数列的个数。 明白这两个点后,就可以着手开始写了。 如果你不知道,怎么写这两次循环,像我上篇文字讲的一样,先从

weixin_44665364的博客 223

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

计算机科学CS新手保姆级入门教学:递归(Recursion)的完整理解与高效设计

递归是一种函数在其定义中直接或间接调用自身的技术。递归基(Base Case):终止条件,防止无限递归。递归关系(Recursive Case):将问题分解为更小的子问题,并调用自身求解。int val;从定义、执行过程到时空分析,理解递归的本质。掌握递归算法设计的通用步骤。学习在递归数据结构和数学归纳场景下的应用。递归是算法设计的核心思想之一。建议多动手实践,从简单问题入手,逐步挑战复杂问题。下一章我们将进入数组与广义表的深入学习,敬请期待!

吾为热爱计科,致力于知识分享的践行者,此博客是我在这条道路上留下的足迹。 1544

算法保姆级入门教学:从零基础到轻松应对面试与竞赛(万字超详细指南)

在编程学习的道路上,算法常常被形容为“拦路虎”。“题目我都看懂了,但就是不知道怎么下手。“别人写的代码很短,我却写了几十行还错漏百出。“递归到底怎么理解?回溯又是什么?“时间复杂度 O(n) 到底意味着什么?这些问题的根源,往往不是“不够聪明”,而是缺乏系统性引导和循序渐进的训练。本文的目标,就是做你的“算法保姆”——✅ 用最通俗的语言解释抽象概念✅ 用最清晰的图示展示执行过程✅ 用最规范的代码示范最佳实践✅ 用最真实的错误案例提醒你避坑计算机专业大一新生转行程序员的自学者。

吾为热爱计科,致力于知识分享的践行者,此博客是我在这条道路上留下的足迹。 225

【二叉查找树/leetcode#538】图解Morris保姆级教学

Morris: 二叉树遍历的更好方案 平台:C++ Morris算法是什么 一种用于二叉树的遍历算法,可以将传统的栈遍历和递归遍历带来的最差O(n)O(n)O(n)的空间复杂度降低到O(1)O(1)O(1) Morris’s in General Morris算法抛弃了栈结构(Stack)来做DFS(Depth First Search),转而利用指针的连接来存取前驱节点 来源题解:Leetcode#538官方题解 给定一个二叉搜索树(Binary Search Tree),把它转换成为累加树(Gre..

Noobi的博客 324

Gemma-3-12B-IT WebUI惊艳效果:生成带详细注释的LeetCode中等题解(含时间复杂度分析)

本文介绍了如何在星图GPU平台上自动化部署gemma-3-12b-it高性能开源大语言模型(LLM)WebUI镜像,并展示了其作为AI编程助手的典型应用场景:生成带有详细注释、思路分析和复杂度评估的LeetCode算法题解,帮助开发者高效学习和准备技术面试。

weixin_35755188的博客 103

保姆级教学第二弹:手把手教你写冒泡排序及其优化O(n)

冒泡排序 按从小到大排序来讲,其实就是通过一遍遍循环,每一次,都把“最大”的数放到每一次循环的最后位置,待排序数列通过相邻两数比较再进行位置交换。而上一篇文章:选择排序,选择排序其实就是,每一次循环,把“最小”的数放到每一次循环的最前面,待排序数列永远与待排序队列的第一个位置的数进行比较,跳着进行交换(这也是为什么选择排序不稳定的原因)。 冒泡排序核心,也就是比较两个相邻的元素,将值大的元素交换到右边。 tips: 对算法一筹莫展时,可以把算法里固定的功能,分解到方法里。对这个方法起个有意义的名字。然后在

weixin_44665364的博客 407

【图解】ACM 选手带你玩转数组。

哼,就这?

用有趣有味的方式,学习有价值的编程知识。 467

【保姆级图解】交换排序 算法详解:直接冒泡排序、快速排序

选择基准:从待排序数组中选择一个元素作为基准(pivot)。分区操作:将数组分为两部分,使得左边部分的所有元素都小于等于基准,右边部分的所有元素都大于等于基准。递归排序:分别对左右两部分递归地进行快速排序。前后指针法是实现分区操作的一种有效方式。前后指针法是快速排序中一种简洁而有效的分区实现方式。它通过两个指针的移动和交换操作,将数组分为两部分,使得基准元素处于其最终的正确位置。虽然快速排序在平均情况下具有出色的性能,但在最坏情况下可能会出现性能退化的问题。

2501_90200491的博客 1740

排序算法-------Java实现------保姆级教学

排序算法 冒泡排序 冒泡排序对大家来说应该是非常不陌生吧,这个排序算法的思路也是十分的简单,主要是以趟作为单位,每趟通过相邻的两个数组元素比较选出一个最大(最小)的数放在数组的最后。(可能唯一需要注意的就是只需要进行数组元素数 - 1 趟即可完成排序) 这个因为实在太简单,直接上代码 package sort.test; import java.util.Arrays; public class TestBubble { public static int[] arr = {4,10,22,5,

fxhhh123的博客 201

NOIP2001经典题‘数的计算’保姆级解析:从暴力递归到高效递推的完整思路

本文深入解析NOIP2001经典题‘数的计算’,从暴力递归到记忆化递归,再到高效递推的完整思路。通过具体代码示例和复杂度分析,帮助读者掌握算法竞赛中的组合计数问题,特别适合信息学奥赛选手和算法爱好者学习。

weixin_30653023的博客 371

保姆级入门教学:Java AI 智能应用开发之 Prompt Engineering 设计高效提示词以优化模型输出

通过系统化的 Prompt Engineering 实践,我们可以显著提升与 AI 模型的协作效率。未来,随着 LangChain4j、Auto-CoT 等工具的成熟,以及 LLM 模型的持续进化,AI 辅助开发将进一步降低技术门槛,推动 Java 生态在智能应用领域的创新发展。立即实践:从下一个 Java AI 项目开始,运用本文介绍的提示词设计方法,体验模型输出质量的飞跃式提升!

吾为热爱计科,致力于知识分享的践行者,此博客是我在这条道路上留下的足迹。 1731
下一篇: 【图解】ACM 选手带你玩转数组。
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值