时间复杂度是指算法执行语句执行的次数。

常见的时间复杂度有以下几种：

描述

时间复杂度

常数阶

O(1)

对数阶

O(logn)

线性阶

O(n)

线性对数阶

O(nlogn)

平方阶

O(n²)

立方阶

O(n³)

n次方阶

O(mⁿ)

指数阶

O(2ⁿ)

阶乘阶

O(n!)

(1) O(1)

O(1)是常量级时间复杂度的一种表示方法，并非只执行一行代码。

代码执行时间不是随着n的增大而增大，这样的代码的时间复杂度都是O(1)。

注意：通常只要算法中不存在循环、递归，即使代码有很多行，时间复杂度仍是O(1)

(2) O(logn)、O(nlogn)对数阶时间复杂度

int i = 1;

while(i<=n){

i=i*2;

}

代码line3是执行次数最多的，只要算出第3行执行的次数，它代表的就是整个代码的时间复杂度。i从1开始取值，每一次循环乘以2。可以看到 i=i*2是一个等比数列，即：2º 2¹  2² ...... 2^k = n。只要算出k是多少，就是执行的次数了  2^k=n -->k=log2n，所以时间复杂度应该为O(log2n)。

int i = 1;

while(i<=n){

i=i*5;

}

很容易就能看出来，应该是O(log5n)。但是上面的O(log2n)和O(log5n)可以通过换底公式换成以2为底的对数，且可以忽略系数，所以都记做 O(logn)。

关于O(nlogn),就是把上面的代码在循环执行n遍了。其中归并排序、快速排序的时间复杂度就是O(nlogn)

(3)O(m+n)、O(m*n)

1. 加法法则(量级最大法则)：总复杂度等于量级最大的那段代码的复杂度。

public static Integer getSum(Integer n){

int sum1 = 0;

int sum2 = 0;

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

sum1 += i;

}

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

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

sum2 += i*j;

}

}

return sum1 + sum2;

}

sum1和sum2分别是 O(n)和O(n²)，对于这三个，我们取量级最大的O(n²)，所以总的时间复杂度就等于量级最大的那段代码的时间复杂度。

2.乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积 。

public static Integer getSum(Integer n){

int sum = 0;

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

sum += func(i);

}

return sum;

}

public static Integer func(Integer x){

int sum = 0;

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

sum += i^2;

}

return sum;

}

func()函数的时间复杂度是 T1(n)=O(n)，如果先把func()函数看成简单的操作，则getSum()函数的时间复杂度是T2(n)=O(n)，所以整个getSum()函数的时间复杂度是T(n)=T2(n)*T1(n)=O(n*n)=O(n^2)

3.循环不仅与n有关，还与执行循环所满足的判断条件有关。

public static Integer func(Integer x, Integer[] arr){

int sum = 0;

int i=0;

while (i < x && arr[i]!=1)

{

i++;

sum += arr[i];

}

return sum;

}

在此循环，如果arr[i]不等于1的话，时间复杂度是O(n)。如果arr[i]等于1的话，则循环执行一次判断跳出，时间复杂度是O(1)。

常见算法的时间复杂度以及空间复杂度如下：

附：

链表实现与时间复杂度分析

数组算法时间复杂度

红黑树的插入和遍历时间复杂度分析