算法时间复杂度

算法时间复杂度定义

在进行算法分析时，语句总的执行次数 T(n) 是关于问题规模 n 的函数，进而分析 T(n) 随 n 的变化情况并确定 T(n) 的数量级。算法的时间复杂度，也就是算法的时间量度，记作： T(n) = O(f(n))。它表示随问题规模 n 的增大，算法执行时间的增长率和 f(n) 的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中 f(n) 是问题规模 n 的某个函数。

O()称之为大 O 记法，一般情况下，随着 n 的增大， T(n) 增长最慢的算法为最优算法。

推导大 O 阶方法

1. 用常数 1 取代运行时间中的所有加法常数。
2. 在修改后的运行次数函数中，只保留最高阶项。
3. 如果最高阶项存在且不是 1，则去除与这个项相乘的常数。 得到的结果就是大 O 阶。

常数阶

int sum = 0, n = 100; //执行一次
sum = (1+n)*n/2; //执行一次
printf("%d", sum); //执行一次

时间复杂度为 O(1)。

线性阶

分析算法的复杂度，关键是要分析循环结构的运行情况。

int i;
for(i = 0; i < n; i++)
{
    /* 时间复杂度为 O(1) 的程序步骤序列 */
}

循环的时间复杂度为 O(n)。

对数阶

int count = 1;
while(count < n)
{
    count = count * 2;
    /* 时间复杂度为 O(1) 的程序步骤序列 */
}

由 $2^x=n$ 得到 $x=log_2n$，所以这个循环的时间复杂度为O(logn)。
注意：在计算机科学中，除非有特别的声明，否则所有的对数都是以 2 为底的。（摘自《数据结构与算法分析》P2）

平方阶

int i,j;
for(i = 0; i < n; i++)
{
    for(j = 0; j < n; j++)
    {
        /* 时间复杂度为 O(1) 的程序步骤序列 */
    }
}

这段代码的时间复杂度为 O(n²)。

如果外循环的循环次数改为了 m，时间复杂度就变为O(m×n)：

int i,j;
for(i = 0; i < m; i++)
{
    for(j = 0; j < n; j++)
    {
        /* 时间复杂度为 O(1) 的程序步骤序列 */
    }
}

所以我们可以总结出，循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。

看接下来的循环嵌套：

int i,j;
for(i = 0; i < m; i++)
{
    for(j = i; j < n; j++)
    {
        /* 时间复杂度为 O(1) 的程序步骤序列 */
    }
}

当 i = 0 时，内循环执行了 n 次，当 i = 1时，执行了 n-1 次，……当 i = n-1 时，执行了 1 次。所以总的执行次数为：

用推导大 O 的方法，这段代码的时间复杂度为 O(n²)。

继续看例子，对于方法调用的时间复杂度又如何分析：

int i,j;
for(i = 0; i < n; i++)
{
    function(i);
}

上面这段代码调用一个函数function：

void function(int count)
{
    print(count);
}

function 函数的时间复杂度是 O(1)，所以整体的时间复杂度为 O(n)。

假如 function 是下面这样的：

void function(int count)
{
    int j;
    for(j = count; j < n; j++)
    {
        /* 时间复杂度为 O(1) 的程序步骤序列 */
    }
}

这和刚才的例子是一样的，只不过把嵌套内循环放到了函数中，所以最终的时间复杂度为 O(n²)。

下面这段相对复杂的语句：

n++; //执行次数为1
function(n); //执行次数为n
int i,j;
for(i = 0; i < n; i++) //执行次数为 n^2
{
    function(i);
}
for(i = 0; i < n; i++) //执行次数为 n(n+1)/2
{
    for(j = i; j < n; j++)
    {
        /* 时间复杂度为 O(1) 的程序步骤序列 */
    }
}

它的执行次数 $f(n)=1+n+n^2+n(n+1)/2=3n^2/2+3n/2+1$，根据推导大 O 阶的方法，最终这段代码的时间复杂度也是 O(n²)。

常见的时间复杂度

执行次数函数	阶	非正式术语
12	O(1)	常数阶
2n+3	O(n)	线性阶
3n2+2n+1	O(n2)	平方阶
5log2n+20	O(logn)	对数阶
2n+3nlog2n+19	O(nlogn)	nlogn 阶
6n3+2n2+3n+4	O(n3)	立方阶
2n	O(2n)	指数阶

常用的时间复杂度所耗费的时间从小到大依次是：