如何计算时间复杂度

本文详细介绍了算法时间复杂度的概念及计算方法,包括确定基本语句、计算执行次数数量级和使用大Ο记号表示时间性能等关键步骤。通过具体例子展示了常见复杂度等级及其在实际算法中的应用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

***************************************************

更多精彩,欢迎进入:http://shop115376623.taobao.com

***************************************************


求解算法的时间复杂度的具体步骤是:

  ⑴ 找出算法中的基本语句;

  算法中执行次数最多的那条语句就是基本语句,通常是最内层循环的循环体。

  ⑵ 计算基本语句的执行次数的数量级;

  只需计算基本语句执行次数的数量级,这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可,可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析,并且使注意力集中在最重要的一点上:增长率。

  ⑶ 用大Ο记号表示算法的时间性能。

  将基本语句执行次数的数量级放入大Ο记号中。

  如果算法中包含嵌套的循环,则基本语句通常是最内层的循环体,如果算法中包含并列的循环,则将并列循环的时间复杂度相加。例如:

  for (i=1; i<=n; i++)
  x++;

  for (i=1; i<=n; i++)
  for (j=1; j<=n; j++)
  x++;

  第一个for循环的时间复杂度为Ο(n),第二个for循环的时间复杂度为Ο(n2),则整个算法的时间复杂度为Ο(n+n2)=Ο(n2)。

  常见的算法时间复杂度由小到大依次为:

  Ο(1)<Ο(log2n)<Ο(n)<Ο(nlog2n)<Ο(n2)<Ο(n3)<…<Ο(2n)<Ο(n!)

Ο(1)表示基本语句的执行次数是一个常数,一般来说,只要算法中不存在循环语句,其时间复杂度就是Ο(1)。Ο(log2n)、Ο(n)、Ο(nlog2n)、Ο(n2)和Ο(n3)称为多项式时间,而Ο(2n)和Ο(n!)称为指数时间。计算机科学家普遍认为前者是有效算法,把这类问题称为P类问题,而把后者称为NP问题。

这只能基本的计算时间复杂度,具体的运行还会与硬件有关。

上面的这部分内容是比较可靠的,理解的时候,可以参看着下面的这部分内容。

在计算算法时间复杂度时有以下几个简单的程序分析法则:

1.对于一些简单的输入输出语句或赋值语句,近似认为需要O(1)时间

2.对于顺序结构,需要依次执行一系列语句所用的时间可采用大O下"求和法则"

求和法则:是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1(n)+T2(n)=O(max(f(n), g(n)))

特别地,若T1(m)=O(f(m)), T2(n)=O(g(n)),则 T1(m)+T2(n)=O(f(m) + g(n))

3.对于选择结构,如if语句,它的主要时间耗费是在执行then字句或else字句所用的时间,需注意的是检验条件也需要O(1)时间

4.对于循环结构,循环语句的运行时间主要体现在多次迭代中执行循环体以及检验循环条件的时间耗费,一般可用大O下"乘法法则"

乘法法则: 是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1*T2=O(f(n)*g(n))

5.对于复杂的算法,可以将它分成几个容易估算的部分,然后利用求和法则和乘法法则技术整个算法的时间复杂度

另外还有以下2个运算法则:

(1) 若g(n)=O(f(n)),则O(f(n))+ O(g(n))= O(f(n))

(2) O(Cf(n)) = O(f(n)),其中C是一个正常数

可以用以上法则对下面程序段进行简单分析

①for (i=0; i<n; i++)

② for (j=0; j<n; j++)

{

③ c[i][j] = 0;

④ for (k=0; k<n; k++)

⑤ c[i][j]= c[i][j]+ a[i][k]* b[k][j];/ * T5(n) = O(1) */

}

第①条与②③④⑤是循环嵌套T1(n)*T2(n)* (T3(n)+ T4(n)* T5(n))= O(n*n*n)即为整个算法的时间复杂度

O(1)<O(log2n)<O(n)<O(n log2 n)<O(n^2)<O(n^3)<O(2^n)

 

转自http://blog.sina.com.cn/s/blog_50ce2abb0100vhem.html


表示时间复杂度的阶有:

O(1) :常量时间阶          O (n):线性时间阶

O(n) :对数时间阶    O(nn) :线性对数时间阶

O (nk): k≥2 ,k次方时间阶

例1  两个n阶方阵的乘法

              for(i=1i<=n; ++i)

                  for(j=1; j<=n; ++j)

                     {   c[i][j]=0 ;

                          for(k=1; k<=n; ++k)

                         c[i][j]+=a[i][k]*b[k][j] ; 

}

由于是一个三重循环,每个循环从1n,则总次数为: n×n×n=n3 时间复杂度为T(n)=O(n3)【立方阶】

例2  {++x; s=0 ;}

x自增看成是基本操作,则语句频度为1,即时间复杂度为O(1) 。【常量阶】

如果将s=0也看成是基本操作,则语句频度为2,其时间复杂度仍为O(1),即常量阶。

例3   for(i=1; i<=n; ++i)

               { ++x; s+=x ; } 

语句频度为:2n,其时间复杂度为:O(n) ,即为【线性阶】

例4   for(i=1; i<=n; ++i)

    for(j=1; j<=n; ++j)

                   { ++x; s+=x ; }

   语句频度为:n*n*2=2n2 ,其时间复杂度为:O(n2) ,即为【平方阶】

定理:若A(n)=amnm +am-1nm-1+…+a1n+a0是一个m次多项式,则A(n)=O(nm)

例5   for(i=2;i<=n;++i)

              for(j=2;j<=i-1;++j)

                    {++x; a[i,j]=x; }

语句频度为:   1+2+3+…+n-2=(1+n-2) ×(n-2)/2

=(n-1)(n-2)/2 =n2-3n+2

 ∴时间复杂度为O(n2),即此算法的时间复杂度为【平方阶】

一个算法时间为O(1)的算法,它的基本运算执行的次数是固定的。因此,总的时间由一个常数(即零次多项式)来限界。而一个时间为O(n2)的算法则由一个二次多项式来限界。

以下六种计算算法时间的多项式是最常用的。其关系为:

     O(1) < O(n) < O(n) < O(nn) < O(n2) < O(n3)

  指数时间的关系为:

    O(2n) < O(n!) < O(nn)

n取得很大时,指数时间算法和多项式时间算法在所需时间上非常悬殊。

1:素数的判断算法。

void prime( int n)

 

 

int i=2 ;

while ( (n%i)!=0 && i*1.0< sqrt(n) )  

     i++ ;

if (i*1.0>sqrt(n) )

      printf(“&d 是一个素数\n” , n) ;

else

      printf(“&d 不是一个素数\n” , n) ;

}

嵌套的最深层语句是i++;其频度由条件( (n% i)!=0 && i*1.0< sqrt(n) )决定,显然i*1.0< sqrt(n) ,时间复杂度O(n1/2)

或者说是O(sqrt(n))

 

2:冒泡排序法。

Void bubble_sort(int a[]int n)

 

change=false;

for (i=n-1; change=TURE; i>1 && change; --i)

for (j=0; j<i; ++j)

if (a[j]>a[j+1])

    {     a[j] ←→a[j+1] ;   change=TURE ; }

}

最好情况:0

最坏情况:1+2+3+⋯+n-1=n(n-1)/2

平均时间复杂度为: O(n2 【平方阶】


<think>好的,用户想了解如何计算算法的时间复杂度。首先,我需要回忆时间复杂度的基本概念和相关规则。根据引用[3],时间复杂度是通过分析语句执行次数T(n)随问题规模n的变化情况来确定的,记作T(n)=O(f(n))。这意味着要找到执行次数的增长率与某个函数f(n)的增长率相同。 接下来,我应该分步骤解释如何计算。第一步是找出基本操作,通常是循环内的操作。例如,在循环中,基本操作可能执行n次。然后,需要计算每个基本操作的执行次数,忽略低阶项和常数系数,只保留最高阶项。例如,如果T(n)=3n²+2n+5,那么时间复杂度是O(n²)。 还需要考虑不同情况,比如最好、最坏和平均情况。引用[4]提到,例如查找数组中的元素,最好情况是O(1),最坏是O(n)。这时候可能需要用大O表示法来表示最坏情况,或者根据情况说明。 另外,常见的时间复杂度类型需要列举,比如O(1)、O(logn)、O(n)、O(nlogn)、O(n²)等,并给出每个的示例,比如循环次数减半是O(logn),双重循环是O(n²)等。 要确保使用正确的LaTeX格式,行内公式用$...$,独立公式用$$...$$。例如,循环次数为n次时,时间复杂度是$O(n)$,而双重循环则是$O(n^2)$。 然后,根据用户提供的引用,引用[3]详细解释了T(n)的分析方法,引用[4]举例了最好和最坏情况,这些都需要在回答中自然地引用。比如在讨论不同情况时,添加[^4]的引用。 可能还需要检查是否有其他关键点,比如递归算法的时间复杂度,但用户的问题可能更关注基础计算。不过,如果涉及递归,可能需要提到主定理,但考虑到用户的需,可能暂时不需要深入。 最后,生成相关问题,比如时间复杂度的意义、常见误区、递归算法的时间复杂度计算等,这些可以帮助用户进一步学习。 现在需要确保回答结构清晰,分步骤说明,并给出示例和公式,符合用户的要。同时,正确应用引用标记,比如在讨论最坏情况时引用[^4],在解释T(n)时引用[^3]。</think>### 如何计算算法的时间复杂度 #### 1. **基本概念** 时间复杂度用于描述算法执行时间随输入规模$n$增长的变化趋势,通常用大O符号($O(f(n))$)表示。其核心是分析算法中**基本操作执行次数的增长率**,忽略常数项和低阶项。 --- #### 2. **计算步骤** ##### **步骤1:确定基本操作** 基本操作是算法中执行次数最多、最影响时间复杂度的操作,通常是循环或递归中的核心操作。 - **示例**:在以下代码中,`sum += i`是基本操作: ```python for i in range(n): sum += i # 基本操作执行n次 ``` ##### **步骤2:计算执行次数表达式$T(n)$** 统计基本操作执行次数与输入规模$n$的关系。 - **示例1**:单层循环 ```python for i in range(n): # 执行n次 print(i) # T(n) = n ``` 时间复杂度为$O(n)$。 - **示例2**:双层循环 ```python for i in range(n): # 执行n次 for j in range(n): # 执行n次 print(i, j) # T(n) = n × n = n² ``` 时间复杂度为$O(n^2)$。 ##### **步骤3:简化表达式(大O表示法)** 保留最高阶项,忽略系数和低阶项: - 若$T(n) = 3n^2 + 2n + 5$,则简化为$O(n^2)$[^3]。 --- #### 3. **常见时间复杂度类型** | 类型 | 示例 | 说明 | |------------|----------------------------|-------------------------------| | $O(1)$ | 直接访问数组元素 | 操作次数与$n$无关 | | $O(\log n)$ | 二分查找 | 每次循环将问题规模减半 | | $O(n)$ | 遍历数组 | 单层循环 | | $O(n \log n)$ | 快速排序、归并排序 | 分治策略,每层复杂度为$O(n)$ | | $O(n^2)$ | 冒泡排序 | 双层循环 | --- #### 4. **分情况讨论** - **最好情况**:输入数据使算法最快完成(如查找元素在数组首位)。 - **最坏情况**:输入数据使算法最慢完成(如查找元素在数组末位),通常以最坏情况作为时间复杂度标准。 - **平均情况**:所有可能输入的期望值,计算较复杂。 --- #### 5. **递归算法的时间复杂度** 使用**递归方程**或**主定理**分析。例如,归并排序的递归公式为: $$ T(n) = 2T\left(\frac{n}{2}\right) + O(n) $$ 通过主定理可得时间复杂度为$O(n \log n)$。 --- #### 6. **示例分析** ##### **示例1:顺序查找** ```python def search(arr, target): for i in range(len(arr)): # 循环n次 if arr[i] == target: # 基本操作 return i return -1 ``` - **最坏情况**:遍历完所有元素,时间复杂度为$O(n)$。 ##### **示例2:斐波那契数列(递归)** ```python def fibonacci(n): if n <= 1: return n return fibonacci(n-1) + fibonacci(n-2) ``` - 时间复杂度为$O(2^n)$(递归树展开后有指数级操作)。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值