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

PLSQL 14.0.6 下载使用教程 众所周知,PLSQL 只是一个oracle第三方开发测试工具,它依赖oracle 客户端搭配使用,但是oracle 客户端有2G,相当庞大,不建议安装。所以我们如果下载安装好PLSQL,再下载好轻量级的支持远程链接的oracle客户端,这样搭配使用可以的话就最好了,答案是可以的。 第一步: PLSQL 下载与安装 PLSQL 14.0.6 下载地址 : https://www.allroundautomations.com/registered-plsqldev/ 下载下来,除了安装路径更改一下, 阅读详情

大家好呀,我是蛋蛋。

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

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
西门子840D新建项目 1、需要一个32位的WIN7或者XP系统,并且已经在系统中安装完成西门子840Dsl开发包和VS2008。(我采用的是XP系统虚拟机) 2、在开始->所有程序找到如下位置 3、在这个位置打开Visual Studio 4、文件->新建->项目 名称和位置都可以随意更改,点击确定。 5、在左侧选择第二个选项进入下面的界面 点击“Add Screen”按钮 可以修改“class name”然后点击“OK”返回上一个界面,再点击“Add Form” 可以修... 阅读详情

相关推荐

抄表程序员的DLMS/COSEM协议实战:从抓包到解析,手把手教你读懂IEC62056报文

本文深入解析DLMS/COSEM协议在智能电表通信中的应用,从报文捕获到数据解析的全流程实战指南。涵盖HDLC帧解析、应用层连接建立、数据请求/响应解码等核心内容,并提供Wireshark配置、OBIS代码速查表等实用工具,帮助开发者快速掌握IEC62056标准下的电能表通信技术。

weixin_29178069的博客 302

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

最好、最坏情况时间复杂度 如下代码表示在一个无序的数组(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

【技术纵览】行为识别前沿模型演进:从CNN到多模态大模型

本文全面解析了行为识别技术从CNN到多模态大模型的演进历程,重点介绍了SlowFast、TimeSformer、VideoMAE和InternVideo等SOTA模型的核心创新与应用实践。通过对比分析各代模型在Kinetics-400等数据集上的表现,揭示了自监督学习和多模态融合如何推动行为识别准确率突破85%,并探讨了工业部署中的技术选型策略与优化方向。

weixin_29169505的博客 156

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

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

技术知识分享 421

关于SVPWM七段式五段式调制后的相电压和线电压波形——大疆DJI技术笔试

1.SVPWM七段式/五段式调制的相电压和线电压波形 脉宽调制(PWM)在并网变流技术中得到了广泛的应用。与正弦脉宽调制(SPWM)的控制方法相比,SVPWM方法具有直流侧电压利用率高,电压谐波小,易于数字化实现等显著的优点,从而使SVPWM在实际的应用中越来越普遍。TMS320F28335是32位浮点的DSP控制器,具有150MHz的高速处理能力,18路PWM输出,与前几代数字信号控制器相比,性能平均提高了50%。其中具体的SVPWM理论实现的原理,请参考我的博客永磁同步电机的矢量控制策略(七)一一一SV

昔时扬尘处 2万+

手把手教你用树莓派蓝牙抓取小米温湿度计2代数据,接入HomeAssistant(附密钥获取避坑指南)

本文详细介绍了如何通过树莓派蓝牙抓取小米温湿度计2代数据并接入HomeAssistant的完整流程。重点解析了获取32位加密密钥的三种方法,包括使用Telink Flasher工具、米家APP抓包和开源工具ATC_MiThermometer,并提供了HomeAssistant集成配置和常见问题排查指南,帮助用户实现稳定可靠的温湿度监测。

一名菜鸟攻城师 779

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

最好和最坏情况时间复杂度(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

C语言从句柄到对象 (一) —— 全局变量的噩梦与“多实例”的救赎

本文探讨了嵌入式开发中句柄(Handle)的概念与应用。通过电机控制案例,分析了传统单例模式在扩展性上的局限,并展示了如何通过句柄实现代码复用:将电机状态封装为结构体,通过指针(句柄)传递实例数据,使同一套逻辑可操作多个实例。文章比较了单例模式与句柄模式的适用场景,建议底层驱动库默认采用句柄模式以提高扩展性。最后指出当前实现仍存在数据暴露风险,预告下期将介绍不透明指针技术实现更安全的封装。全文揭示了句柄作为C语言实现模块化和面向对象设计的关键作用。

一路往蓝-Anbo 的博客 1342

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

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

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

Linux故障排查和性能优化面试题及参考答案

在 Linux 系统中,负载(Load Average)是衡量系统繁忙程度的一个重要指标,它表示系统在特定时间间隔内运行队列中的平均进程数。负载值反映了系统当前的工作压力,主要包括 CPU 等待运行的进程数量和处于不可中断睡眠状态(通常是等待 I/O 操作完成)的进程数量。负载平均值通常有三个数值,分别代表过去 1 分钟、5 分钟和 15 分钟内的系统平均负载。例如,在使用uptime命令或查看文件时,会看到类似这样的输出,这三个数值依次表示过去 1 分钟、5 分钟和 15 分钟的负载平均值。

大模型大数据攻城狮的专栏 1083

使用Python与OpenCV实现基于霍夫变换的圆形缺陷检测与定位详细教程

本文详细探讨了如何使用Python和OpenCV库,通过图像边缘检测和霍夫变换实现圆形对象的检测与缺陷定位。我们不仅介绍了算法的基本原理,还通过具体的代码示例展示了如何在实际应用中实现这些技术。对于工业检测和医学影像分析,本文的方法提供了高效且易于实现的解决方案。随着图像处理技术的不断发展,未来我们可以期待更多新算法和新技术的应用,如深度学习与传统方法的结合,以及多传感器融合技术的引入,这将进一步提升缺陷检测与定位的效率和准确性。

qq_38334677的博客 1299

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

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

优快云博客 7601

【重温童年】基于tkinter模块设计的Q宠大乐斗武器升星模拟器:重温经典,畅享休闲时光

与传统的Q宠大乐斗不同,这款模拟器还加入了一个创新的功能——自定义升星概率。玩家可以根据自己的喜好和策略,为不同的武器设置不同的成功率和降级率。比如,你可以将“嗜血”这把武器的升星难度设置得极高,以体现其稀有性和强大威力;也可以将“平底锅”这样的普通武器设置得相对容易升星,让玩家在升级过程中感受到更多的成就感。这种自定义的概率设置,不仅增加了游戏的趣味性和挑战性,还让玩家在升级过程中有了更多的策略和选择。你可以根据自己的武器库和卷轴数量,制定出最合适的升级计划,从而在游戏中占据先机。

nmdbbzcl的博客 1241

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

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

weixin_42035282的博客 440

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

leetcode刷题时间空间复杂度

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

yan57628的博客 223

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

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

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

weixin_44665364的博客 223

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

计算机科学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 选手带你玩转数组。
codegoudan
博客等级 码龄5年 27粉丝 27原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值