究竟什么是时间复杂度，怎么求时间复杂度，看这一篇就够了

5.

时间复杂度就是用来方便开发者估算出程序的运行时间

logn是以什么为底_log的底logn是以什么为底_log的底


logn是以什么为底_log的底


我们该如何估计程序运行时间呢，我们通常会估计算法的作单元数量，来代表程序消耗的时间， 这里我们默认CPU的每个单元运行消耗的时间都是相同的。

随着数据规模n的增大，算法执行时间的增长率和f(n)的增长率相同，这称作为算法的渐近时间复杂度，简称时间复杂度，记为 O(f(n))

这里就要说一下这个大O，什么是大O呢，很多同学说时间复杂度的时候都知道O(n)，O(n^2)，但说不清什么是大O

算法导论给出的解释： 大O用来表示上界的 ，当用它作为算法的最坏情况运行时间的上界，就是对任意数据输入的运行时间的上界。

同样算法导论给出了例子：拿插入排序来说，插入排序的时间复杂度我们都说是O(n^2)

但是在数据本来有序的情况下时间复杂度是O(n)，也就对于所有输入情况来说，最坏是O(n^2) 的时间复杂度，所以称插入排序的时间复杂度为O(n^2)

同样的同理我们在看一下快速排序，都知道快速排序是O(nlogn)，但是当数据已经有序情况下，快速排序的时间复杂度是O(n^2) 的，严格从大O的定义来讲，快速排序的时间复杂度应该是O(n^2)

所以这里大家知道这么一回事就好了

面试中面试官不会针对快速排序的时间复杂度问题来讨论O的定义， 大家知道讨论的时间复杂度就是指一般情况下的时间复杂度就好了。

大家要对算法的时间复杂度有这样的一个概念

就是同一个算法的时间复杂度不是一成不变的，和输入的数据形式依然有关系

我们主要关心的还是一般情况下的数据形式 。

面试中说道算法的时间复杂度是多少指的都是一般情况

但是如果面试官和我们深入探讨一个算法的实现以及性能的时候 我们就要时刻想着 数据用例的不一样 时间复杂度也是不同的，这一点同学们要注意

这个图中我们可以看出 不同算法的时间复杂度 在不同数据输入规模下的异 。

我们在决定使用那些算法的时候 ，不是时间复杂越低的越好，要考虑数据规模，如果数据规模很小 甚至可以用O(n^2)的算法比 O(n)的更合适

就像上图中图中 O(5n^2) 和 O(100n) 在n为20之前 很明显 O(5n^2)是更优的，所花费的时间也是最少的。

那我们为什么在计算时间复杂度的时候要忽略常数项系数呢，也就说O(100n) 就是O(n)的时间复杂度，O(5n^2) 就是O(n^2)的时间复杂度

而且要默认O(nvoid main()) 优于O(n^2) 呢 ？

因为 大O其实就是数据量级突破一个点且数据量级非常大的情况下所表现出的时间复杂度 ，这个点也就是 常数项系数已经不起决定性作用的点。

我们平时说这个 算法的时间复杂度是logn的，一定是log 以2为底n的对数么？

其实不然，也可以是以10为底n的对数，也可以是以20为底n的对数，但我们统一说 logn，也就是忽略底数的描述。

为什么可以这么做呢？

如下图所示

如我们有两个算法的时间复杂度 分别是log以2为底n的对数 和 log 以10为底n的对数

那么这里如果大家还记得我们高中数学的话， 应该不能理解 以2为底n的对数 = 以2为底10的对数 乘以 以10为底n的对数

那这里以2为底10的对数 是一个常数，而我在上面已经讲述了我们计算时间复杂度是忽略常数项系数的

抽象一下 log 以i为底n的对数 等于 log 以j为底n的对数，所以我们忽略了i，直接说是logn，正式因为logij 是就一个常数

所以，这样就应该不难理解了 我们为什么忽略底数了

有时候，我们去计算时间复杂度的时候 发现不是一个 简单的O(n) 或者O(n^2)， 而是一个复杂的表达式，例如：

O(2n^2 + 10n + 1000)

那这里我们通常如何描述这个算法的时间复杂度呢，一种方法就是简化法

去掉运行时间中的加法常数项 （因为常数项并不会因为n的增大而增加计算机的作次数）

O(2n^2 + 10n)

去掉常数系数 （我们刚刚已经详细讲过为什么可以去掉常数项的原因了）

O(n^2)

如果这一步同学们理解有困难，那也可以做提取n的作，变成 O(n(n+1)) ，省略加法常数项后 也别变成了

O(n^2)

所以我们说：我们这个算法的算法时间复杂度是 O(n^2)

也可以用另一种简化的思路，当n大于40的时候 ， 这个复杂度 会一直小于 O(3n^2)

O(2n^2 + 10n + 1000) < O(3n^2)

所以说 我们省略掉常数项系数最终时间复杂度也是 O(n^2)

题目描述：找出n个字符串中相同的两个字符串（设这里只有两个相同的字符串）

这个时间复杂度其实是不对的。

这里 一些同学忽略了字符串比较的时间消耗，这里并不像int 型数字做比较那么简单

那么我们再想一下其他解题思路

那我们来看看这种算法的时间复杂度

快速排序时间复杂度 为O(nlogn)，依然要考虑字符串的长度是m，那么快速排序每次的比较都要有m次的字符比较的作，就是 O(mnlogn)

之后我们还要遍历一遍这n个字符串找出两个相同的字符串，别忘了遍历的时候依然要比较字符串，所以总共的时间复杂度是 O(mnlogn + nm)

我们对 O(mnlogn + nm) 进行简化作，把 mn 提取出来变成 O(mn(logn + 1)) ，

在省略常数项的时间复杂度是 O(mnlogn) ， 那我们比较一下时间效率 O(mnlogn) 是不是比种方法 O(mnn) 更快一些呢

很明显 O(mnlogn) 要优于 O(mnn)

所以 先把字符串排序在遍历一遍找到两个相同字符串的方式要比直接枚举的方式更快 。

通过这个例子 希望大家对时间复杂的是怎么算的有一个初步的理解和认识。

对数函数的一些公式是什么

对数基本恒根式的对数等于被开方数的对数除以根指数log[N^(1/n)]=(1/n)logN对数的换底公式：log_b_N=log_a_N/log_a_b等式：a^log_a_N=N

积的对数等于对数的和log(MN)=logM+logN 省略底数a

幂的对数等我们通过一道题目，来看一下具体时间复杂度应该怎么算于对数的对数乘指数log(N^m)=mlogN

证明对数换底公式：logbN＝logaNlogab（a，b，N都是正数，a≠1，b≠1）

#include #include

证明：令logbN=x，则bx=N，两边同取以a为底的商的对数等于对数的log(M/N)=logM-logN对数得：logbxa=logaN，

∴x=logNalogba，

若数学中的log没有指出底数,那是否其底数默认为10？比如logN等价于log(10)N？括号为下标.

Log函数定义域即log后面的定义域> 0 ，如y=logx ，定义域即x>0 ， logx的值域为R。对数函数是以幂(真数)为自变量，指数为因变量，底数为常的函数。

是的 数学书上有专门说明 没有写底数的都是以10为底

除了n^2 次的遍历次数外， 字符串比较依然要消耗m次作（m也就是字母串的长度），所以时间复杂度是 O(mnn)

是的，不过log10N一般会简写为lgN

不是，lg的底数才是10，你可以设为a

ln就是以欧拉常数e为底

两种情况

1.以10为底 记作lgx

2.以e为底 记作lnx

若log以m为底3的对数 log即以10为底的对数，计算器直接logN即可

log3/logm

同时乘以 1/设算法的问题规模为n，那么作单元数量便用函数f(n)来表示logm<1/logn logn< logm n

0

或1

或0

指数对数函数判断大小方法

我们先排对n个字符串按字典序来排序，排序后n个字符串就是有序的，意味着两个相同的字符串就是挨在一起

可以根据指对函数的单调性和找中间量两中方法。

但是我们依然说快速排序是O(nlogn)的时间复杂度，这个就是业内的一个默认规定，我们这里说的O 代表的就是一般情况，不是严格的上界

先说单调性方法，

如果是底数一样可以用此方法，底数大于一，函数单增，指数越大，值越大，底数大于零小于一，函数单减，指数越小，值越大。对于对数函数，也是如此。

对于指数函数，如果指数相同，底数不同，实质上应用的是幂函数的单调性。

对于对数函数，如果真数相同，底数不同，如果底数都大于一，那么，告诉你一个规律，对数函数的图像，在x轴以上底数小的在上面，底数大的在下面，在X轴以下相反。这样，画出图像，竖着画一条平行于Y轴的线，就一目了然了。其实，总结一下的话，就是真数相同，底数大于一，底数越小，对数值越大。相反，底数小于一，在x轴以上底数小的在下面，底数大的在上面。

还有一种计算的方法，对于底数不同，真数相同的，可以很快的化同底，运用了一个结论：logm

n=1/logn

m9可用换底公式推。比如log2

5和log7

5=1/log

52,log7

5=1/log5

7因为log5

7>log

52所以1/log5

7<1/log

52即log7

5

找中间值法，一般是对于对数函数而言的，先看正负，若一正一负，自然好，比如lg2和lg0.5.

若为同号，就和1比，如lg8(＜1）和lg12（＞1）

还有，有时可以先化简再比较，原则是化为同底数，什么样的对数可以化为同底？这里不要使用换底公式的话，一般是底数或真数同为某个数的幂次才行。比如log2

5和log8

27(以八为底），log8

27=log2

3

有些情况，对数值符号相同，也都大于一，真数底数都不同，也不能用公式直接化同底，用初等办法就无法做了，高考是不会考的。在此不加赘述。

望采纳！

算法时间复杂度o(1)和o(2)的区别？？？

扩展资料时间复杂度O(n^2)，就代表数据量增大n倍时，耗时增大n的平方倍，这是比线性更高的时间复杂度。比如冒泡排序，就是典型的O(n^2)的算法，对n个数排序，需要扫描n×n次。

O后面的括号中有一个函数，指明某个算法的耗时/耗空间与数据增长量之间的关系。其中的n代表输入数据的量。

所以我们说的时间复杂度都是省略常数项系数的，是因为一般情况下我们都是默认数据规模足够的大，基于这样的事实 我们给出的算法时间复杂的的一个排行如下所示：

时间复杂度为O(n)，就代表数据量增大几倍，耗时也增大几倍。比如常见的遍历算法。所以O(2)相比于O(1)数据量会更多，同时需要执行的时间会更多。

一般情况下，算法中基本作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),存在一个正常数c使得fnc>=T(n)恒成立。记作T(n)=O(f(n)),称O(f(n))为算法的渐进时间复杂度，简称时间复杂度。

比如O(logn)，当数据增大n倍时，耗时增大logn倍（这里的log是以2为底的，比如，当数据增大256倍时，耗时只增大8倍，是比线性还要低的时间复杂度）。二分查找就是O(logn)的算法，每找一次排除一半的可能，256个数据中查找只要找8次就可以找到目标。

O(nlogn)同理，就是n乘以logn，当数据增大256倍时，耗时增大2568=2048倍。这个复杂度高于线性低于平方。归并排序就是O(nlogn)的时间复杂度。

参考资料来源：百度百科—算法复杂度

时间复杂度 数据结构 c＋＋？

log 就是以10为底

选D，nl求导，利用函数的单调性来比较，结果下面那为已经给出来了，你可以试下ogn

外层复杂度显然为n

内层循环，只看的一次

令 2的x次方分之n 等于1，x 等于 以2为底n的对数

根据乘法原理，总的时间复杂度就是 n乘以logn，底数可以省略。

外循环 O(n)这没什么可说的了

内循环 O(log2n)

解释：

for(int j=i;j>0;j/=2)

也就是说内循环一次i被分成x(未知数)个2

i=2^x

x=logi（i是内层循环的n）

x=logn(应该是log2n(以2为底n的对数)，但是以常数为底的对数，变化趋势大致相同，所以可以把看作log2n与logn近似相等)

O(nlog2n)和O(nlogn)都可以作为这个程序的时间复杂度

时间复杂度 求出的结果就是近似值(留高阶,去低阶,去常数)

O(n^3+n^2+n+11111)

O(n^3)

这是因为外循环是线性的，所以它的时间复杂度是O(N)，而内循环的初始值是i，而且每次循环结束以后，循环控制变量的值减半，所以内循环的时间复杂度是O(LogN)，所以结合起来就是选择d

《信息论》一书中，公式里有许多log没有写底数。请问他们的底数是多少？为什么？

例如上图中 20 就是那个点 ，n只要大于20 常数项系数已经不起决定性作用了。

您好！

O(1)常数阶 < O(logn)对数阶 < O(n)线性阶 < O(n^2)平方阶 < O(n^3)(立方阶) < O(2^n) (指数阶)

信息学中一般默认为2

因为很多的程序设计中涉及“二分法”，而且计算机为2进制，这也是一种时间复杂度的表示方式，因此是2

比如时间复杂度是logn，那么就代表Log2 n，比如你有64个数，那么用6次就能完成这个程序的运行。

低数默认为2