时间复杂度与空间复杂度的计算方法_时间复杂度和空间复杂度怎么计算

时间复杂度

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

大O符号表示法

1、用常数1取代运行时间中的所有加法常数
2、在修改后的运行次数函数中，只保留最高阶项
3、如果最高阶项存在且不是1，那么我们就去除于这个项相乘的常数。

1. 常数阶O(1);

我们来看一下这个例子，用的是java，内容就是打印3条语句，问这个程序的时间复杂度是多少？

void func() {
	System.out.println("111");
	System.out.println("111");
	System.out.println("111");
}
1
2
3
4
5

O（3）？不是，按照时间复杂度的概念“T（n）是关于问题规模为n的函数”，这里跟问题规模有关系吗？没有关系，用我们的第一个方法，用常数1取代运行时间中的所有加法常数，时间复杂度为O（1）。

void func(){
    int i=0;//执行1次
    i++;//执行1次
    i++;//执行1次
    i++;//执行1次
}
1
2
3
4
5
6

共执行了4次，所以时间复杂度为O(4);根据大O推导法，略去常数，所以此函数的时间复杂度也为O(1);

2. 线性阶O(n);

void func(){
	int sum = 0;
	for(int i=1;i<=100;i++) {
		sum = sum + i;
	}
}
1
2
3
4
5
6

这段代码，for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度。

void func()//时间复杂度为O(1)的函数
{
   printf("大O推导法");//执行1次
}
/*
在main中，func共被执行了n次，所以main的时间复杂度为O(n);
*/
//加入main函数被修改成如下
void main()
{
   for(int i=0;i<n;i++)
    {
        func();
        func();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在main中，func共被执行了2n次，main的时间复杂度为O(2n);根据大O推导法，略去常数系数，所以main的时间复杂度仍为为O(n);

3. 平方阶O(n²)

void main() {
	int sum = 0;
	for(int i=1;i<=100;i++) {
		for(int j=1;j<=100;j++)
			sum = sum + i;
	}
}
1
2
3
4
5
6
7

外层i的循环执行一次，内层j的循环就要执行100次，所以外层执行100次，那么总的就需要执行100100次，那么n次呢？这段代码其实就是嵌套了2层n循环，它的时间复杂度就是 O(nn)，即 O(n²)

4. 对数阶O(logn)

void main() {
	int i=1;
	int n= 100;
	while(i<n) {
		i = i*2;
	}	
}
1
2
3
4
5
6
7

从上面代码可以看到，在while循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了。我们试着求解一下，假设循环x次之后，i 就大于 2 了，此时这个循环就退出了，也就是说 2 的 x 次方等于 n，2^x = n， 那么 x = log2^n
也就是说当循环 log2^n 次以后，这个代码就结束了。因此这个代码的时间复杂度为：O(logn)

5. 线性对数阶O(nlogN)

线性对数阶O(nlogN) 其实非常容易理解，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n * O(logN)，也就是了O(nlogN)。

就拿上面的代码加一点修改来举例：

for(m=1; m<n; m++)
{
    i = 1;
    while(i<n)
    {
        i = i * 2;
    }
}
1
2
3
4
5
6
7
8

6.立方阶O(n³)、K次方阶O(n^k)

参考上面的O(n²) 去理解就好了，O(n³)相当于三层n循环，其它的类似。

耗费的时间

补充常用的时间复杂度所耗费的时间从小到大依次是：
O(1 )< O(logn) < O(n) < O(n*logn) < O(n²)< O(n³) < O(2^n) < O(n!) < O(n^n)

空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的一个量度，同样反映的是一个趋势，我们用 S(n) 来定义。

空间复杂度比较常用的有：O(1)、O(n)、O(n²)，我们下面来看看：

空间复杂度 O(1)

如果算法执行所需要的临时空间不随着某个变量n的大小而变化，即此算法空间复杂度为一个常量，可表示为 O(1)
举例：

int i = 1;
int j = 2;
++i;
j++;
int m = i + j;
1
2
3
4
5

代码中的 i、j、m 所分配的空间都不随着处理数据量变化，因此它的空间复杂度 S(n) = O(1)

空间复杂度 O(n)

我们先看一个代码：

int[] m = new int[n]
for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}
1
2
3
4
5
6

这段代码中，第一行new了一个数组出来，这个数据占用的大小为n，这段代码的2-6行，虽然有循环，但没有再分配新的空间，因此，这段代码的空间复杂度主要看第一行即可，即 S(n) = O(n)