大家好，关于下面程序的时间复杂度为很多朋友都还不太明白，不过没关系，因为今天小编就来为大家分享关于算法的时间复杂度取决于的知识点，相信应该可以解决大家的一些困惑和问题，如果碰巧可以解决您的问题，还望关注下本站哦，希望对各位有所帮助！
本文目录
- C语言题目:下面程序段的时间复杂度是
- 递归算法时间复杂度题目求解答...
- 下面程序段的时间复杂度为___。(n>1)
- 算法的时间复杂度定义
- 面程序段的时间复杂度是( ) i=1; while(i<=n) i=i*3;
一、C语言题目:下面程序段的时间复杂度是
1、为了计算这段代码的时间复杂度，我们应考虑循环被执行了几次，而判断循环执行的次数的关键，就在于判断s和i是如何增长的。
2、不难发现，每执行一次循环，i从0开始增加1。而s是对i的求和。
3、因此，不妨假设循环体已经执行了x次，则此时i= x- 1，s= 0+ 1+ 2+ 3+...+(x- 1)。
4、根据等差数列求和的 *** 质，s= x(x- 1)/ 2。当s> n时，即x(x- 1)/ 2> n时循环结束。
5、如果将(x- 1)近似成x的话，不难看出，x约等于√(2n)。
6、而循环体内的代码每执行一次的时间复杂度是Θ(1)的。
7、所以，这个代码段的时间复杂度为Θ(√n)。
二、递归算法时间复杂度题目求解答...
是指对一个问题的求解，可以通过同一问题的更简单的形式的求解来表示.
并通过问题的简单形式的解求出复杂形式的解.
递归程序设计是程序设计中常用的一种 *** ，它可以解决所有有递归属 *** 的问题，并且是行之有效的.
但对于递归程序运行的效率比较低，无论是时间还是空间都比非递归程序更费，若在程序中消除递归调用，则其运行时间可大为节省.
以下讨论递归的时间效率分析 *** ，以及与非递归设计的时间效率的比较.
算法是对特定问题求解步骤的一种描述.
对于算法的优劣有其评价准则，主要在于评价算法的时间效率，算法的时间通过该算法编写的程序在计算机中运行的时间来衡量，所花费的时间与算法的规模n有必然的联系，当问题的规模越来越大时，算法所需时间量的上升趋势就是要考虑的时间度量.
算法的时间度量是依据算法中更大语句频度（指算法中某条语句重复执行的次数）来估算的，它是问题规模n的某一个函数f(n).
算法时间度量记作：t（n）=o（f（n））
它表示随问题规模n的增大，算法执行时间的增长率和f（n）的增长率相同，称作算法的时间复杂度，简称时间复杂度[2].
（1）x=x+1;（2）for(i=1;i<=n;i++)
x=x+1;（3）for(j=1;j<=n;j++)
以上三个程序段中，语句x=x+1的频度分别为1，n，n2，则这三段程序的时间复杂度分别为o（1），o（n），o（n2）.
求解过程为：先给出问题规模n的函数的表达式，然后给出其时间复杂度t（n）.
但是在现实程序设计过程中，往往遇到的问题都是比较复杂的算法，就不能很容易地写出规模n的表达式，也比较难总结其时间复杂度.
下面举例说明递归函数的时间复杂度的分析 *** .
三、下面程序段的时间复杂度为___。(n>1)
1、i=1； while（i<=n） i=i*2的时间复杂度O(log2n)。
2、整段代码语句，中循环体只有一个while（i<=n），执行的次数是：
3、i= 1，i= 1*2=2，判断2是否小于等于n，是则继续循环，否则跳出循环。
4、i=2，i= 2*2=4，判断4是否小于等于n，是则继续循环，否则跳出循环。
5、i=4，i= 4*2=8，判断8是否小于等于n，是则继续循环，否则跳出循环。
6、根据规律发现，循环次数由log2n决定，所以复杂度是O(log2n)。
7、一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。
8、但不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
四、算法的时间复杂度定义
时间复杂度是总运算次数表达式中受n的变化影响更大的那一项(不含系数)
比如：一般总运算次数表达式类似于这样：
a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f
a！=0时，时间复杂度就是O(2^n);
a,b=0,c<>0=>O(n^2)依此类推
(1) for(i=1;i<=n;i++)//循环了n*n次，当然是O(n^2)
(2) for(i=1;i<=n;i++)//循环了(n+n-1+n-2+...+1)≈(n^2)/2，因为时间复杂度是不考虑系数的，所以也是O(n^2)
(3) for(i=1;i<=n;i++)//循环了(1+2+3+...+n)≈(n^2)/2,当然也是O(n^2)
k+=10*i; i++;}//循环了n-1≈n次，所以是O(n)(5) for(i=1;i<=n;i++)
//循环了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6(这个公式要记住哦)≈(n^3)/3，不考虑系数，自然是O(n^3)
另外，在时间复杂度中，log(2,n)(以2为底)与lg(n)(以10为底)是等价的，因为对数换底公式：
所以，log(2,n)=log(2,10)*lg(n),忽略掉系数，二者当然是等价的
二、计算 *** 1.一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
2.一般情况下，算法的基本 *** 作重复执行的次数是模块n的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n））。随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。
在计算时间复杂度的时候，先找出算法的基本 *** 作，然后根据相应的各语句确定它的执行次数，再找出T（n）的同数量级（它的同数量级有以下：1，Log2n，n，nLog2n，n的平方，n的三次方，2的n次方，n！），找出后，f（n）=该数量级，若T(n)/f(n)求极限可得到一常数c，则时间复杂度T（n）=O（f（n））。
按数量级递增排列，常见的时间复杂度有：
常数阶O(1),对数阶O(log2n),线 *** 阶O(n),线 *** 对数阶O(nlog2n),平方阶O(n^2)，立方阶O(n^3),...， k次方阶O(n^k),指数阶O(2^n)。
其中，1.O(n)，O(n^2)，立方阶O(n^3),...， k次方阶O(n^k)为多项式阶时间复杂度，分别称为一阶时间复杂度，二阶时间复杂度。。。。2.O(2^n)，指数阶时间复杂度，该种不实用3.对数阶O(log2n),线 *** 对数阶O(nlog2n)，除了常数阶以外，该种效率更高
c[ i ][ j ]=0;//该步骤属于基本 *** 作执行次数：n^2
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ];//该步骤属于基本 *** 作执行次数：n^3
则有 T（n）= n^2+n^3，根据上面括号里的同数量级，我们可以确定 n^3为T（n）的同数量级
则有f（n）= n^3，然后根据T（n）/f（n）求极限可得到常数c
则该算法的时间复杂度：T（n）=O（n^3)
定义：如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数
T(n)称为这一算法的“时间复杂 *** ”。
当输入量n逐渐加大时，时间复杂 *** 的极限情形称为算法的“渐近时间复杂 *** ”。
我们常用大O表示法表示时间复杂 *** ，注意它是某一个算法的时间复杂 *** 。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。
此外，一个问题本身也有它的复杂 *** ，如果某个算法的复杂 *** 到达了这个问题复杂 *** 的下界，那就称这样的算法是更佳算法。
“大O记法”：在这种描述中使用的基本参数是
n，即问题实例的规模，把复杂 *** 或运行时间表达为n的函数。这里的“O”表示量级(order)，比如说“二分检索是 O(lo *** )的”,也就是说它需要“通过lo *** 量级的步骤去检索一个规模为n的数组”记法 O( f(n))表示当 n增大时，运行时间至多将以正比于 f(n)的速度增长。
这种渐进估计对算法的理论分析和大致比较是非常有价值的，但在实践中细节也可能造成差异。例如，一个低附加代价的O(n2)算法在n较小的情况下可能比一个高附加代价的 O(nlo *** )算法运行得更快。当然，随着n足够大以后，具有较慢上升函数的算法必然工作得更快。
以上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶，记作T(n)=O(1)。如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
语句2的频度是(n-1)*(2n+1)=2n^2-n-1
该程序的时间复杂度T(n)=O(n^2).
设语句2的频度是f(n),则：2^f(n)<=n;f(n)<=log2n
j=k的时候,内层循环的次数为k当i=m时, j可以取 0,1,...,m-1,所以这里最内循环共进行了0+1+...+m-1=(m-1)m/2次所以,i从0取到n,则循环共进行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6所以时间复杂度为O(n^3).
我们还应该区分算法的最坏情况的行为和期望行为。如快速排序的最
坏情况运行时间是 O(n^2)，但期望时间是 O(nlo *** )。通过每次都仔细地选择基准值，我们有可能把平方情况(即O(n^2)情况)的概率减小到几乎等于 0。在实际中，精心实现的快速排序一般都能以(O(nlo *** )时间运行。
访问数组中的元素是常数时间 *** 作，或说O(1) *** 作。一个算法如果能在每个步骤去掉一半数据元素，如二分检索，通常它就取 O(lo *** )时间。用strcmp比较两个具有n个字符的串需要O(n)时间。常规的矩阵乘算法是O(n^3)，因为算出每个元素都需要将n对
元素相乘并加到一起，所有元素的个数是n^2。
指数时间算法通常来源于需要求出所有可能结果。例如，n个元素的 *** 共有2n个子集,所以要求出所有子集的算法将是O(2n)的。指数算法一般说来是太复杂了，除非n的值非常小，因为，在这个问题中增加一个元素就导致运行时间加倍。不幸的是，确实有许多问题(如著名的“巡回售货员问题”)，到目前为止找到的算法都是指数的。如果我们真的遇到这种情况，通常应该用寻找近似更佳结果的算法替代之。
五、面程序段的时间复杂度是( ) i=1; while(i<=n) i=i*3;
i=1，只是赋初值，只赋值一次的。
若n=100; i=1; while(i<=n) i=i*3；
i的值的变化过程为：3，9，27，81，243。
各程序设计语言有自己的赋值语句，赋值语句也有不同的类型。所赋“值”可以是数字，也可以是字符串和表达式。
注意很多语言都使用“等于号”（即“=”）来作为赋值号，所以可能和和平时的理解不同，在使用的时候应予以注意。
例如，给变量a赋值一个数为12，则格式为：a= 12，注意：变量（即a）只能是一字母，而赋予的值可以是一个式子，当它是式子时，a的值就是这个式子的结果。
C语言规定，变量要先定义才能使用，也可以将定义和赋值在同一个语句中进行：
关于下面程序的时间复杂度为到此分享完毕，希望能帮助到您。
