算法时间复杂度的计算

合集下载

时间复杂度计算题

题目：给定一个长度为n 的数组，要求找出数组中最大的k 个元素。

解题思路：

可以使用快速选择算法来求解。快速选择算法是快速排序的一种改进，它可以在平均情况下找到第k 小的元素，而时间复杂度为

O(n)。

具体实现步骤如下：

随机选择一个基准元素，将数组分为两部分，小于基准的元素和大于基准的元素。

如果基准元素正好是第k 小的元素，则返回基准元素。

如果基准元素比第k 小的元素大，则在左边的子数组中继续查找第k 小的元素。

如果基准元素比第k 小的元素小，则在右边的子数组中继续查找第k 小的元素。

重复步骤1 到步骤4，直到找到第k 小的元素。

时间复杂度分析：

在最坏情况下，每次查找都可能会访问到整个数组，因此时间复杂

度为O(n^2)。但实际上，快速选择算法在平均情况下表现良好，时间复杂度为O(n)。

for循环时间复杂度计算公式

for循环是编程中最基本的循环结构之一，它可以让程序重复执行某个操作。在计算机科学中，我们通常会关注算法的时间复杂度，即算法执行所需的时间与输入规模之间的关系。对于for循环，我们也可以通过公式来计算其时间复杂度。

for循环时间复杂度计算公式通常可以表示为：T(n) = a * n + b，其中n为输入规模，a和b为常数。

这个公式的含义是，for循环的执行时间取决于输入规模n以及循环体内的操作的执行次数。常数a表示每次循环需要执行的操作数量，常数b表示循环体外的一些额外操作所需的时间。因此，我们可以通过计算循环体内操作的执行次数来确定a的值。

具体来说，我们可以通过以下方法来计算for循环的时间复杂度： 1. 首先，我们需要确定循环的控制变量，即循环次数。通常情

况下，循环次数与输入规模n有关。

2. 其次，我们需要确定循环体内操作的执行次数。这通常需要

根据具体的代码实现来确定。

3. 最后，我们可以将循环次数和每次循环需要执行的操作数量

相乘，再加上循环体外的一些额外操作所需的时间，就可以得到时间复杂度的公式。

举个例子来说，假设我们有以下代码：

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {

// do something

}

这段代码中，外层循环的控制变量是i，内层循环的控制变量是j。循环次数分别为n和n，因此总的循环次数为n * n = n^2。循环体内的操作是“do something”，执行次数也为n^2次。因此，a的

matlab 时间空间复杂度计算

matlab 时间空间复杂度计算在计算机科学中，时间复杂度和空间复杂度是评估算法性能的两个重要指标。而在MATLAB中，对于算法的时间复杂度和空间复杂度的计算与其他编程语言类似。本文将从理论和实际应用的角度，详细介绍MATLAB中时间复杂度和空间复杂度的计算方法，并探讨如何优化算法以提高性能。

时间复杂度是衡量算法执行时间随输入规模增长而增长的程度，通常用大O符号表示。它描述了算法执行所需的基本操作次数，并提供了一种粗略的估计。在MATLAB中，我们可以使用复杂度符号库来计算时间复杂度。

常见的时间复杂度包括：

-常数时间复杂度O(1)：算法的执行时间不受输入规模的影响，例如直接访问数组元素。

-线性时间复杂度O(n)：算法的执行时间与输入规模n成正比，例如遍历数组或链表。

-对数时间复杂度O(log n)：算法的执行时间随输入规模n的对数增加，例如二分查找。

-平方时间复杂度O(n^2)：算法的执行时间与输入规模n的平方成正比，例如嵌套循环。

在MATLAB中，可以通过分析循环、递归和函数的调用来判断算法

的时间复杂度。具体方法如下：

1.计算循环次数：分析算法中的循环结构，找出循环变量的变化

规律并计算循环次数。通常情况下，循环结构的复杂度与循环次数成

正比。

2.分析递归调用：递归算法的时间复杂度可以通过递归树来计算。根据递推关系式和递归调用的次数，可以得到递归算法的复杂度。

3.考虑函数调用开销：函数调用也会耗费一定的时间，特别是输

入和输出参数的传递。因此，在计算算法复杂度时，需要考虑函数调

用的开销。

matlab 时间空间复杂度计算

MATLAB是一种用于数学计算、可视化和算法开发的高级语言和交互式环境。它在工程和科学领域广泛应用，对于大规模数据处理和复杂算法的计算能力得到了极大的发展。其中，时间空间复杂度计算是MATLAB中的一个重要概念，本文将从时间复杂度和空间复杂度两个方面详细介绍MATLAB中的计算方法。

1. 时间复杂度计算

时间复杂度是指算法执行所需的时间。在MATLAB中，我们通常使用tic和toc两个函数来计时，在算法执行前使用tic函数，执行后使用toc函数，通过求差来得到算法执行的时间。除了tic和toc函数外，MATLAB还提供了profile和profview两个函数，用于算法的性能分析和优化。通过这些函数，我们可以清晰地了解算法的时间消耗，进而对算法进行优化。

2. 空间复杂度计算

空间复杂度是指算法执行所需的内存空间。在MATLAB中，我们可以使用whos函数来查看当前工作空间中的变量及其占用的内存大小。通过whos函数，我们可以直观地了解算法执行期间占用的内存空间情况，从而对算法进行合理的内存优化。

3. 时间空间复杂度计算案例

下面，我们以一个简单的案例来说明MATLAB中时间空间复杂度的计算。我们需要对一个较大的数据集进行排序操作，这时我们可以使用

MATLAB中的内置函数sort来实现。在算法执行前，我们可以使用

tic函数开始计时，在排序操作完成后使用toc函数来结束计时。我们可以通过whos函数来查看排序操作所占用的内存空间大小。通过这

些操作，我们可以得到该排序算法的时间复杂度和空间复杂度，进而

算法时间复杂度的计算公式

算法时间复杂度是衡量算法效率的重要指标，它是指算法运行时间随着问题规模的增大而增长的速度。

计算算法时间复杂度需要考虑以下几个因素：

1. 循环结构的次数：算法中循环结构执行的次数是影响时间复杂度的重要因素之一。

2. 嵌套循环结构：如果算法中有多个嵌套循环结构，那么时间复杂度的计算就要考虑这些循环的嵌套次数。

3. 条件判断语句：如果算法中有条件判断语句，那么时间复杂度的计算需要根据条件的判断次数进行计算。

4. 递归调用：如果算法中有递归调用，那么时间复杂度的计算需要根据递归的次数进行计算。

算法时间复杂度的计算公式可以表示为：

T(n) = O(f(n))

其中，T(n)表示算法的时间复杂度，f(n)表示算法执行的时间，O表示算法的渐进时间复杂度。

根据算法的实际情况，可以通过分析算法中循环结构的次数、嵌套次数、条件判断次数、递归次数等因素，来确定算法的时间复杂度。

- 1 -

最大公约数的三种算法复杂度分析时间计算

1.辗转相除法（欧几里得算法）

辗转相除法是一种基于递归的算法，它通过不断地用两个数中较大的

数除以较小的数，直到两个数相等为止。这时，较小的数就是最大公约数。例如，求解49和28的最大公约数：

-49÷28=1 (21)

-28÷21=1 (7)

-21÷7=3 0

所以最大公约数为7

辗转相除法的时间复杂度分析如下：

设两个数中较大的数为a，较小的数为b，a mod b 的结果为r。

- 最好情况：当b能够整除a时，时间复杂度为O(loga)，因为每次

递归时a和b的值都会减少至原来的一半。

-最坏情况：当a和b互质时，时间复杂度为O(a/b)。例如，当a=2n 时，每次递归的b的值都会减少至1

- 平均情况：时间复杂度是O(logab)的。

2.更相减损术

更相减损术是一种基于减法的算法，它通过不断地用两个数中较大的

数减去较小的数，直到两个数相等为止。这时，较小的数就是最大公约数。例如，求解49和28的最大公约数：

-28-21=7

-21-7=14

-14-7=7

所以最大公约数为7

更相减损术的时间复杂度分析如下：

设两个数中较大的数为a，较小的数为b。

- 最好情况：当a和b的差值为1时，时间复杂度为O(logb)，因为

每次减法操作后的差值都会减少一半。

-最坏情况：当a和b互质时，时间复杂度为O(a-b)。例如，当a=2n 时，每次减法操作的差值都会减少至1

-平均情况：时间复杂度为O(a-b)的。

3. Stein算法（二进制法）

Stein算法是一种基于位运算的算法，它通过在两个数中同时除去2

如何计算时间复杂度和空间复杂度

计算时间复杂度和空间复杂度是衡量算法效率的重要方法，可以通过

对算法的代码进行分析和推算来得出。

时间复杂度描述了算法运行时间随输入规模增长而增长的趋势，通常

用大O符号表示。在计算时间复杂度时，我们需要关注算法中的循环、递归、条件分支等关键代码块。

以下是计算时间复杂度的一些常见方法：

1.计算常数时间复杂度：如果一个算法的代码只包含固定数量的操作，不随输入规模变化，那么它的时间复杂度为O(1)。例如，简单的赋值、

比较和常量运算等操作。

2.计算线性时间复杂度：如果一个算法的代码中包含一个循环，该循

环的迭代次数与输入规模n成正比，那么其时间复杂度为O(n)。例如，

遍历一个数组或者链表的操作。

3.计算平方时间复杂度：如果一个算法的代码中包含两个嵌套的循环，外层循环的迭代次数与输入规模n成正比，内层循环的迭代次数也与输入

规模n成正比，那么其时间复杂度为O(n^2)。例如，二重循环嵌套的矩

阵操作。

4.计算指数时间复杂度：如果一个算法的代码中包含递归调用，且递

归次数与输入规模n成正比，那么其时间复杂度可能是指数级别的，如

O(2^n)。例如，求解斐波那契数列的递归算法。

计算空间复杂度是用来衡量算法所需的额外存储空间随输入规模增长

而增长的趋势。

以下是计算空间复杂度的一些常见方法：

1.计算固定空间复杂度：如果一个算法的代码所需的额外存储空间不随输入规模变化，那么它的空间复杂度为O(1)。例如，仅需要几个变量来存储中间计算结果的操作。

2.计算线性空间复杂度：如果一个算法的代码所需的额外存储空间随输入规模n成正比，那么它的空间复杂度为O(n)。例如，需要创建一个数组或链表来存储输入数据的操作。

如何计算时间复杂度和空间复杂度

计算算法的时间复杂度和空间复杂度是对算法效率的度量和评估。时间复杂度是衡量算法执行时间的度量，用大O表示；空间复杂度是衡量算法所需内存空间的度量，也用大O表示。下面将详细介绍如何计算时间复杂度和空间复杂度。

一、计算时间复杂度

时间复杂度是在不同规模输入下，算法的执行时间增长速度的度量。常用的有最坏情况时间复杂度、平均情况时间复杂度和最好情况时间复杂度。我们以最坏情况时间复杂度为例进行介绍。

1.观察算法中的基本操作

在计算时间复杂度时，首先要观察算法中的基本操作是什么，通常是循环、递归、条件判断等。这些基本操作的执行次数将决定算法的执行时间。

2.确定基本操作的执行次数

确定基本操作的执行次数需要根据具体代码进行分析。通过观察代码中的循环和条件判断，可以确定每个操作的执行次数。

3.建立时间复杂度方程

根据基本操作的执行次数，可以建立时间复杂度方程。通常在时间复杂度方程中，可以使用大O表示法来表示执行次数与输入规模n的关系。例如，如果一个操作执行次数是3n+2，则可以表示为O(n)。

4.求解时间复杂度

的情况：

-如果算法中有多个循环，则分别计算每个循环的时间复杂度，并取最大值。

-如果算法中有递归操作，则递归的时间复杂度需要通过递归树的形式进行分析。

-如果算法中有条件判断，则需要分别计算每个条件分支的时间复杂度，并取最大值。

空间复杂度是衡量算法在执行时所需的内存空间大小的度量。与计算时间复杂度类似，通常也使用大O表示法来表示。

1.观察算法中的空间使用情况

在计算空间复杂度时，需要观察算法中的变量、数组、递归栈等的空间使用情况。这些空间的消耗将决定算法的空间复杂度。

递归算法时间复杂度计算

递归算法是一种通过函数调用自身来解决问题的算法。在计算递归算法的时间复杂度时，通常要考虑递归调用的次数及每次递归调用所需的时间复杂度。

具体来说，递归算法的时间复杂度可以用如下公式表示：

T(n) = aT(n/b) + O(f(n))

其中，a是递归调用的次数，n/b表示每次递归所处理的数据规模，f(n)表示除了递归调用外，剩余操作的时间复杂度。

根据主定理，如果a=1，b=2，则时间复杂度为O(log n)；如果a>1，b=1，则时间复杂度为O(n^logb a)；如果a<1，则时间复杂度为O(1)。

需要注意的是，递归调用次数可能会对时间复杂度产生重大影响，因此需要尽可能的减少递归调用次数。

总之，计算递归算法的时间复杂度需要确定递归调用次数、每次调用的数据规模以及剩余操作的时间复杂度。

迭代法求时间复杂度的运算

迭代法是算法设计中常见的一种方法，它通过反复迭代计算来逐

步逼近问题的解，常用于求解数值问题。在算法分析中，我们需要了

解迭代法的时间复杂度，以评估算法的执行效率。

首先，我们来看一下迭代法的基本流程。迭代法通常需要设定初

始值，然后通过更新操作反复迭代计算，直至满足所设定的停止条件。对于同一个问题而言，迭代法的流程是固定的，因此研究迭代法的时

间复杂度可以直接从迭代次数和每次迭代的计算量入手。

在分析迭代法时间复杂度时，有两种常见的方法，分别是迭代次

数法和迭代公式法。

迭代次数法适用于迭代次数已知的算法。其基本思想是，对于每

个迭代次数，计算所执行的基本运算次数，然后将各次运算的次数累

加起来即可得到总运算次数，进而计算出时间复杂度。例如，对于求

解平方根的牛顿迭代算法，其迭代次数通常为固定值，而每次迭代需

要进行若干次求导和求解方程的基本运算。那么，我们可以通过对这

些基本运算次数进行计算，得到该算法的时间复杂度。

而迭代公式法则适用于存在递推公式的算法。这种方法通常需要

把算法的每一步操作都用递推公式表示出来，形成整个算法的递推关系。然后，根据递推关系，计算出执行每一步操作所需的时间复杂度，最终累加起来即可得到整个算法的时间复杂度。例如，对于Fibonacci 数列的递归算法，其递归关系可以用F(n) = F(n-1) + F(n-2)表示，

那么根据递归公式，我们可以计算出算法运行时每个变量被计算的次数，从而得到此算法的时间复杂度。

总的来说，迭代法是一种常用的求解问题的方法，研究其时间复

c加加时间复杂度计算公式

c加加时间复杂度计算公式C加加时间复杂度计算公式。

在计算机科学中，时间复杂度是衡量算法性能的重要指标之一。它描述了算法的运行时间随着输入规模的增加而增加的速度。时间复杂度通常用大O符号来表示，而在C++编程语言中，我们可以使用C加加（C++）来编写算法，并通过时间复杂度计算公式来评估算法的效率。

时间复杂度的计算公式通常是基于算法中基本操作的执行次数。基本操作是指算法中执行次数最多的那部分代码，通常是循环、递归、条件语句等。通过对基本操作的执行次数进行分析，我们可以得到算法的时间复杂度。

在C++中，我们可以通过编写算法代码并使用计时器来测量算法的运行时间，然后根据输入规模来分析算法的时间复杂度。但更常见的做法是通过对算法代码进行分析，推导出时间复杂度的计算公式。

下面我们将介绍一些常见的时间复杂度计算公式，并通过实例来说明如何在

C++中计算算法的时间复杂度。

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

常数时间复杂度表示算法的运行时间与输入规模无关，即无论输入规模大小如何，算法的运行时间都保持不变。这通常是由于算法中只包含了一些固定的基本操作，比如赋值操作、加减乘除等。在C++中，常数时间复杂度的算法通常是一些简单的数学运算或者逻辑判断，比如下面这个例子：

```cpp。

int sum(int a, int b) {。

return a + b;

}。

```。

在这个例子中，函数sum的运行时间与输入规模无关，因此它的时间复杂度为O(1)。

2. 线性时间复杂度，O(n)。

线性时间复杂度表示算法的运行时间与输入规模成正比，即随着输入规模的增加，算法的运行时间也会线性增加。在C++中，线性时间复杂度的算法通常是一些需要遍历输入数据的算法，比如下面这个例子：

时间复杂度的计算

在计算时间复杂度时，我们需要考虑算法中的循环、递归、分支和函数调用等因素。

以下是一些常见的时间复杂度：

1.常数时间复杂度O(1)：无论输入规模如何增大，算法的运行时间保持不变。例如，访问一个数组中的其中一个元素。

2.线性时间复杂度O(n)：算法的运行时间与输入规模呈线性关系。例如，遍历一个长度为n的数组。

3. 对数时间复杂度O(log n)：算法的运行时间与输入规模的对数呈比例关系。例如，二分查找算法。

4.平方时间复杂度O(n^2)：算法的运行时间与输入规模的平方成正比。例如，冒泡排序算法。

5.立方时间复杂度O(n^3)：算法的运行时间与输入规模的立方成正比。例如，矩阵相乘算法。

6.指数时间复杂度O(2^n)：算法的运行时间与2的n次方成正比。例如，穷举法求解旅行商问题。

在计算时间复杂度时，通常会将算法的执行步骤以及每个步骤的时间复杂度进行分析，然后取最大的时间复杂度作为算法的时间复杂度。

有时候，算法的时间复杂度并不仅仅受输入规模的影响，还可能受到算法的设计、数据结构的选择等因素的影响。

在实际应用中，我们通常更关注算法的平均时间复杂度和最坏时间复杂度。平均时间复杂度是指算法在所有可能的输入中的平均运行时间，最坏时间复杂度是指算法在所有可能的输入中的最长运行时间。

通过对算法的时间复杂度进行分析，我们可以评估一个算法的效率，从而选择更加高效的算法来解决问题。

数据结构与算法（一）时间复杂度、空间复杂度计算

数据结构与算法（⼀）时间复杂度、空间复杂度计算

⼀、时间复杂度计算

1、时间复杂度的意义

复杂度分析是整个算法学习的精髓，只要掌握了它，数据结构和算法的内容基本上就掌握了⼀半

1. 测试结果⾮常依赖测试环境

2. 测试结果受数据规模的影响很⼤

所以，我们需要⼀个不⽤具体的测试数据来测试，就可以粗略地估计算法的执⾏效率的⽅法，即时间、空间复杂度分析⽅法。

2、⼤ O 复杂度表⽰法

1)、可以将计算时间复杂度的⽅式和计算代码执⾏次数来进⾏类别

int cal(int n) {

int sum = 0;

int i = 1;

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

sum = sum + i;

}

return sum;

}

第 2、3 ⾏代码分别需要 1 个 unit_time 的执⾏时间，第 4、5 ⾏都运⾏了 n 遍，所以需要 2n * unit_time 的执⾏时间，所以这段代码总的执⾏时间就是(2n+2) * unit_time。可以看出来，所有代码的执⾏时间 T(n) 与每⾏代码的执⾏次数成正⽐。

2)、复杂⼀点的计算

int cal(int n) { ----1

int sum = 0; ----2

int i = 1; ----3

int j = 1; ----4

for (; i <= n; ++i) { ----5

j = 1; ----6

for (; j <= n; ++j) { ----7

sum = sum + i * j; ----8

} ----9

} ----10

} ----11

T(n) = (2n^2+2n+3)unit_time

数据结构求时间复杂度例题

数据结构中的时间复杂度分析是计算机科学中一个重要的概念，它帮助我们理解算法的效率。时间复杂度通常表示为\(O\) 符号，表示算法运行时间随着输入规模增长的增长率。接下来，我将通过一个具体的例题来解释如何分析算法的时间复杂度。

例题：归并排序

归并排序是一种经典的排序算法，其基本思想是将数组分成若干个子序列，先使每个子序列有序，然后再使子序列段间有序。归并排序的算法描述如下：

1. 将数组分成若干个子序列，每个子序列包含一个元素。

2. 对每个子序列进行排序。

3. 重复步骤1 和2，直到整个数组排序完成。

要求：分析归并排序算法的时间复杂度。

解答：

归并排序算法的时间复杂度分析可以从两个方面入手：一是分解过程，二是合并过程。

1. 分解过程：

在分解过程中，每次将数组分成两个子序列，需要进行一次比较和交换操作。设数组的长度为\(n\)，那么分解过程需要进行\(n-1\) 次操作。由于每次分解操作都将问题规模减半，因此分解过程的时间复杂度为\(O(n)\)。

2. 合并过程：

在合并过程中，需要将两个有序子序列合并成一个有序序列。设每个子序列的长度为\(m\)，那么合并过程需要进行\(m\) 次比较和交换操作。由于每次合并操作都将问题规模减半，因此合并过程的时间复杂度为\(O(m)\)。

综合分解过程和合并过程，归并排序算法的总时间复杂度为\(O(n)\)。

需要注意的是，归并排序的空间复杂度为\(O(n)\)，因为在排序过程中需要使用与输入数组相同大小的辅助数组。在实际应用中，归并排序的效率受到存储空间和输入规模的影响，但对于大规模数据排序，归并排序仍然是一种高效的算法。

递归时间复杂度计算公式

摘要：

1.递归时间复杂度概念介绍

2.递归时间复杂度计算公式

3.递归时间复杂度举例说明

4.降低递归时间复杂度的方法

5.总结

正文：

递归时间复杂度计算公式是递归算法分析中非常重要的一个环节。在计算机科学中，时间复杂度是评估算法效率的关键指标，而递归算法的时间复杂度分析更具挑战性，因为它涉及到函数调用和子问题的解决。

一、递归时间复杂度概念介绍

递归时间复杂度是指递归算法在运行过程中，所需的时间资源与问题规模的关系。通常用大O符号表示，例如O(n)，表示时间复杂度与问题规模n成正比。在递归算法中，我们需要关注两个关键因素：递归深度和子问题规模。

二、递归时间复杂度计算公式

递归时间复杂度的计算公式如下：

T(n) = 2T(n/2) + c

其中，T(n/2)表示递归深度为n/2时的时间复杂度，c表示常数项，即不随问题规模变化的部分。

三、递归时间复杂度举例说明

以汉诺塔问题为例，描述如下：

功能：将一个长度为n的序列从源柱子移动到目标柱子。

算法描述：

1.判断序列长度n，若n为1，直接将元素移动到目标柱子，时间复杂度为1。

2.若序列长度n大于1，则递归地将n-1个元素的序列从源柱子移动到中间柱子，时间复杂度为2(n-1)。

3.将序列的最后一个元素从源柱子移动到目标柱子，时间复杂度为1。

4.递归地将n-1个元素的序列从中间柱子移动到目标柱子，时间复杂度为2(n-1)。

我们可以发现，汉诺塔问题的时间复杂度为O(2^n)，这是一个典型的递归时间复杂度公式。

四、降低递归时间复杂度的方法

1.提前终止条件：在算法设计中，设置一个合适的提前终止条件，可以有效地降低递归时间复杂度。例如，在汉诺塔问题中，当序列长度为1时，直接解决问题，而不进行递归调用。

【数据结构】时间复杂度和空间复杂度计算

时间复杂度AND空间复杂度专项

时间维度：是指执⾏当前算法所消耗的时间，我们通常⽤「时间复杂度」来描述。

空间维度：是指执⾏当前算法需要占⽤多少内存空间，我们通常⽤「空间复杂度」来描述。

时间复杂度

⼀个算法花费的时间与算法中语句的执⾏次数成正⽐例，哪个算法中语句执⾏次数多，它花费时间就多。⼀个算法中的语句执⾏次数称为语句频度或时间频度。记为 T(n)。

常见的算法时间复杂度由⼩到⼤依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜Ο(nk)＜Ο(2n) ，随着问题规模 n 的不断增⼤，上述时间复杂度不断增⼤，算法的

执⾏效率越低

常见的时间复杂度：

常数阶 O(1)

对数阶 O(log2n)

线性阶 O(n)

线性对数阶 O(nlog2n)

平⽅阶 O(n^2)

⽴⽅阶 O(n^3)

k 次⽅阶 O(n^k)

指数阶 O(2^n)

常见阶数串讲

常数阶 O（1）

没有循环结构，代码上万⾏都可以，消耗并不伴随某个的增长⽽增长，都是O（1）

对数阶O（log2n）

举个例⼦

int n=1000;

int i=1;

while(i<=n){

i=i*2;

}

cout<<"啦啦啦啦i="<<i<<endl;

看在while循环中执⾏了多少次：while终⽌条件是i>n的时候，即当2的x次⽅等于n时结束循环，那么显然x=log2n。也就是说while循环执⾏了log2n次后就结束了，那么这个算法的时间复杂度就是log2n。