[数据结构_初阶] 时间复杂度,空间复杂度

目录:

  • 1.算法效率
  • 2.时间复杂度
    • a.大O的渐进表示法
  • 3.时间复杂度例题
    • (1)计算BinarySearch的时间复杂度?
  • 4.空间复杂度
    • (1)例一:计算BubbleSort的空间复杂度?
    • (2)例二:计算Fibonacci的空间复杂度?
    • (3)例三:计算阶乘递归Factorial的空间复杂度?

1.算法效率

算法效率分为两种:一种是时间效率又称时间复杂度,主要衡量一个算法的运行速度;一种是空间效率又称空间复杂度,主要衡量一个算法所需要的空间;这两种复杂度都采用大O的渐进表示法表示。
随着计算机行业的迅速发展,计算机的储存容量已经达到了很高的程度,现在基本上只考虑一个算法的时间复杂度,空间复杂度已经不再需要特别关注了
[数据结构_初阶] 时间复杂度,空间复杂度_第1张图片

2.时间复杂度

算法中的基本操作的执行次数为算法的时间复杂度

a.大O的渐进表示法

用以下代码为例说明:

void Func1(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);
}

先计算Func1执行的基本操作次数
F(N)=N^2+2*N+10
实际上我们计算时间复杂度时,只需要大概的执行次数,所以我们使用大O渐进表示法

大O渐进表示法的规则:
• 用常数1取代运行时间中的所有加法常数。
• 在修改后的运行次数函数中,只保留最高阶项。
• 如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。
使用大O渐进表示法算的Func1的时间复杂度为: O(N^2)

通过上面我们发现大O的渐进表示法去掉了那些对结果影响不大的项,简洁的表示出了执行次数
另外有些算法的时间复杂度存在最好.平均和最坏情况:
最坏情况: 任意输入规模的最大运行次数(上界)
平均情况: 任意输入规模的期望运行次数
最好情况: 任意输入规模的最小运行次数(下界)
例如:
在一个长度为N数组中搜索一个数据x
最好情况: 1次找到
最坏情况: N次找到
平均情况:    N/2次找到
在实际中一般情况关注的是算法的最坏运行情况

3.时间复杂度例题

(1)计算BinarySearch的时间复杂度?

时间复杂度为O(logN)

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;
}

[数据结构_初阶] 时间复杂度,空间复杂度_第2张图片

4.空间复杂度

空间复杂度:是对一个算法在运行过程中临时占用存储空间大小的量度,空间复杂度算的是变量的个数
用以下代码为例说明:

(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;
 }
}

[数据结构_初阶] 时间复杂度,空间复杂度_第3张图片
BubbleSort中定义了 4 个变量,使用了常数个额外空间,所以空间复杂度为O(1)

(2)例二:计算Fibonacci的空间复杂度?

long long* Fibonacci(size_t n) {
 if(n==0)
 return NULL;
 
 long long * fibArray =
 (long long *)malloc((n+1) * sizeof(long long));
 fibArray[0] = 0;
 fibArray[1] = 1;for (int i = 2; i <= n ; ++i)
 {
 fibArray[i ] = fibArray[ i - 1] + fibArray [i - 2];
 }
 return fibArray ;
}

因为malloc开辟了n+1个空间,所以空间复杂度为O(N)

(3)例三:计算阶乘递归Factorial的空间复杂度?

long long Factorial(size_t N) {
 return N < 2 ? N : Factorial(N-1)*N; }

递归了N次,开辟了N个栈帧,每个栈帧使用了常数个空间,所以空间复杂度为O(N)

你可能感兴趣的