数据结构001 - 时间复杂度与空间复杂度

0. 前言

1、什么是数据结构？
数据结构（Data Structure）是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。

2、什么是算法？
算法（Algorithm）是定义良好的计算过程，取一个和或一组值为输入，并产生一个或一组值为输出。即算法是一系列的计算步骤，用来将输入数据转化成输出结果。

1. 算法效率

算法在编写成可执行程序后，运行时需要耗费时间资源和空间（内存）资源。因此一个算法的好坏，一般从时间和空间两个维度衡量，即 时间复杂度 和 空间复杂度。

时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间。 在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以如今已经不需要再特别关注一个算法的空间复杂度。

2. 时间复杂度

2.1 时间复杂度的概念

在计算机科学中，算法的时间复杂度是一个函数，它定量地描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说是不能计算出来的，只有将程序放在机器上运行才能知道，但是这样很繁琐。
所以才有了时间复杂度这样的分析方式，一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，称为算法的时间复杂度。

即找到某条基本语句与问题规模N之间的数学表达式，就是计算出了该算法的时间复杂度。

2.2 大O的渐进表示法

// 请计算一下 Func 基本操作执行了多少次？
void Func(int N) {
	int count = 0;
	for (int i = 0; i < N ; ++ i) {
		for (int j = 0; j < N ; ++ j){
			++count;
		}
	}
	for (int k = 0; k < 2 * N ; ++ k) {
		++count;
	}
	int M = 10;
	while (M--) {
		++count;
	}
	printf("%d\n", count);
} 

Func 执行的基本操作次数：

N = 10，F(N) = 130
N = 100，F(N) = 10210
N = 1000，F(N) = 1002010

实际计算时间复杂度时，并不一定要计算精确执行次数，而只需要计算大概执行次数，这里可以使用大O的渐进表示法。
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：
（1）用常数1取代运行时间中的所有加法常数。
（2）在修改后的运行次数函数中，只保留最高阶项。
（3）如果最高阶项存在且不是1，则去除与这个项相乘的常数。得到的结果就是大O阶。

使用大O的渐进表示法以后，Func 的时间复杂度：

N = 10，F(N) = 100
N = 100，F(N) = 10000
N = 1000，F(N) = 1000000

可以发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了地表示了执行次数。
另外，有些算法的时间复杂度存在最好、平均和最坏情况。
最坏情况：任意输入规模的最大运行次数（上界）。
平均情况：任意输入规模的期望运行次数。
最好情况：任意输入规模的最小运行次数（下界）。

例如：在一个长度为 N 的数组中搜索一个数据 X。
最好情况：1 次找到。
最坏情况：N 次找到。
平均情况：N/2 次找到。
在实际中，一般关注地是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)。

2.3 常见时间复杂度计算举例

实例1、

void Func1(int N) {
	int count = 0;
	for (int k = 0; k < 2 * N ; ++ k) {
 		++count;
 	}
	int M = 10;
	while (M--) {
 		++count;
 	}
	printf("%d\n", count);
}

解析：基本操作执行了 2N+10 次，通过推导大O阶方法知道，时间复杂度为 O(N)。

实例2、

void Func2(int N, int M) {
	int count = 0;
	for (int k = 0; k < M; ++ k) {
 		++count;
 	}
	for (int k = 0; k < N ; ++ k) {
 		++count;
 	}
	printf("%d\n", count);
}

解析：基本操作执行了 M+N 次，有两个未知数 M 和 N，时间复杂度为 O(N+M)。

实例3、

void Func3(int N) {
	int count = 0;
	for (int k = 0; k < 100; ++ k) {
 		++count;
 	}
	printf("%d\n", count);
}

解析：基本操作执行了 100 次，通过推导大O阶方法，时间复杂度为 O(1)。

实例4、

// 计算 strchr 的时间复杂度
const char * strchr ( const char * str, int character );

解析：基本操作执行最好 1 次，最坏 N 次。时间复杂度一般看最坏，时间复杂度为 O(N)。

实例5、冒泡排序

// 计算 BubbleSort 的时间复杂度
void BubbleSort(int* a, int n) {
	assert(a);
	for (size_t end = n; end > 0; --end) {
 		int exchange = 0;
 		for (size_t i = 1; i < end; ++i){
 			if (a[i-1] > a[i]){
				Swap(&a[i-1], &a[i]);
				exchange = 1;
			}
		}
 		if (exchange == 0)
			break;
	}
}

解析：基本操作执行最好 N 次，最坏执行了 (N*(N+1))/2 次，通过推导大O阶方法并且时间复杂度一般看最坏，时间复杂度为 O(N^2)。

实例6、二分查找

// 计算 BinarySearch 的时间复杂度
int BinarySearch(int* a, int n, int x) {
	assert(a);
	int begin = 0;
	int end = n-1;
	while (begin < end) {
		int mid = begin + ((end-begin)>>1);
		if (a[mid] < x)
			begin = mid+1;
		else if (a[mid] > x)
			end = mid;
		else
			return mid;
	}
	return -1;
}

解析： 基本操作执行最好 1 次，最坏 O(logN) 次，时间复杂度为 O(logN)。
注：logN 在算法分析中表示是底数为 2，对数为 N。有些地方会写成 lgN。

分析：
N/2/2/2… = 1
2^X = N
X = log2^N

实例7、

// 计算阶乘递归 Factorial 的时间复杂度
long long Factorial(size_t N) {
	if(0 == N)
		return 1;
	
	return Factorial(N-1)*N;
}

解析：基本操作递归了 N 次，时间复杂度为 O(N)。

实例8、

// 计算斐波那契递归 Fibonacci 的时间复杂度
long long Fibonacci(size_t N) {
	if(N < 3)
		return 1;
	
	return Fibonacci(1) + Fibonacci(2);
}

每一次函数调用的执行次数都是二次，随着递归的展开，执行次数也在不断的增加，可以用下图表示：

则其执行次数：F(n)=1+2+4+8+…+2^(n-2)，可以看出 F(n) 是一个等比数列的前 n 项和。

解析：基本操作递归了 2^N 次，时间复杂度为 O(2^N)。

3. 空间复杂度

空间复杂度也是一个数学函数表达式，是对一个算法在运行过程中 临时额外占用存储空间大小的度量。
空间复杂度不是程序占用了多少 bytes 的空间，计算变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用 大O渐进表示法。

注意： 函数运行时所需要的栈空间（存储参数、局部变量、一些寄存器信息等）在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

空间复杂度计算举例

实例1、

// 计算 BubbleSort 的空间复杂度
void BubbleSort(int* a, int n) {
	assert(a);
	for (size_t end = n; end > 0; --end) {
 		int exchange = 0;
 		for (size_t i = 1; i < end; ++i){
 			if (a[i-1] > a[i]){
				Swap(&a[i-1], &a[i]);
				exchange = 1;
			}
		}
 		if (exchange == 0)
			break;
	}
}

解析：总共开辟了 end、exchange、i 三个变量，即使用了常数个额外空间，所以空间复杂度为O(1)。

实例2、

//计算Fibonacci的空间复杂度
long long* Fibonacci(size_t n) {
	if(n==0)
		return NULL;
 
	long long * fibArray = new long long[n+1];
	fibArray[0] = 0;
	fibArray[1] = 1;for (int i = 2; i <= n ; ++i){
		fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
	}
	return fibArray ;
}

解析：总共动态开辟了 (n+1) 个大小为 long long 类型的数组，n为未知常数，所以空间复杂度为O(N)。

实例3、

// 计算阶乘递归 Factorial 的空间复杂度
long long Factorial(size_t N) {
	if(0 == N)
		return 1;
	
	return Factorial(N-1)*N;
}

解析：每次函数的调用是要建立栈帧的，递归 Fac 函数建立栈帧的个数为 N 个，每个栈帧都使用了常数个空间，即（常数 * N），常数可忽略，所以 Fac 函数的空间复杂度为 O(N)。

4. 常见复杂度对比

一般算法常见的复杂度如下：

复杂度对比：O(n!) > O(2ⁿ) > O(n²) > O(nlog(2)n) > O(n) > O(log(2)n) > O(1)

5. 复杂度的 OJ 练习

5.1 消失的数字

解决方法：
1、排序： 冒泡(N²)、qsort快排(nlog(2)N)（不符合条件）

2、映射： 下标法（每个值是多少就对应多少的下标），时间复杂度 O(N)，空间复杂度 O(N)。

	int *ret = (int*)malloc(sizeof(int)*(numsSize+1));
    int i = 0;
    for(i = 0; i<numsSize+1; i++){
        ret[i] = -1;
    }
    for(i = 0; i<numsSize; i++){
        ret[nums[i]] = nums[i];
    }
    for(i = 0; i<numsSize+1; i++){
        if(ret[i] == -1){
            return i;
        }
    }
    return -1;
}

3、异或： 给一个值 X = 0，X 先跟 [0, n] 所有值异或，X 再跟数组中每个值异或，最后 X 就是缺的那个数字。

int missingNumber(int* nums, int numsSize){
	int x = 0;
	// 跟 [0, n] 异或
	for(int i=0; i<=numsSize; ++i){
		x ^= nums[i];
	}
	
	// 再跟数组中的值异或 
   	for(int i=0; i<=numsSize; ++i){
   		x ^= i;
   	}
   	return x;
}

4、将 0 -> n 的和减去原数组的所有数据 (0+1+2+3…+n) - (a[0] + a[1] + a[2] + a[3] + …+ a[n-1])
时间复杂度O(N)、空间复杂度O(1)

	int sum = 0;
	int i = 0;
	int n = numsSize;
	sum = (n + 1) * n / 2; //等差数列的和的公式
	for (i = 0; i < numsSize; i++){
		sum -= nums[i];
	}
	return sum;
}