【数据结构与算法】时间复杂度与空间复杂度（大O渐进表示法）

最新推荐文章于 2023-08-18 15:50:17 发布

是小黄呀~

最新推荐文章于 2023-08-18 15:50:17 发布

阅读量416

点赞数 11

分类专栏：数据结构和算法

本文链接：https://blog.csdn.net/qq_62306969/article/details/126615333

版权

数据结构算法时间复杂度空间复杂度大O表示法

关键词由CSDN通过智能技术生成

数据结构和算法专栏收录该内容

10 篇文章 1 订阅

订阅专栏

前言

文者执笔，武者持矛，程序猿的武器则是数据结构和算法。很多同学可能学了C语言好像没有什么用，还是有很多题目不会写，这就和数据结构和算法有关系。只有学好数据结构和算法，才能真正意义上的迈入计算机编程的大门！

今天就让小黄带着大家首先了解一下算法最基础的知识：时间和空间复杂度

什么是数据结构

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

即数据结构决定怎么存储数据，是存放的方式。

什么是算法

算法( Algorithm )：就是定义良好的计算过程，他取一个或一组的值为输入，并产出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

即算法决定怎么使用数据，是对于问题的解决方法，是一个过程。

算法复杂度

如何评价一个算法的好坏？主要从两个角度进行判断：时间和空间。

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。

时间复杂度

时间复杂度概念

算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。

一个算法执行所耗费的时间，从理论上说，是无法计算的，只有将程序放在机器上跑起来，才能知道。而且不同机器的配置是不一样的，机器的硬件设备也决定了程序运行的快慢，所以选择了一个函数式来表达复杂度，这样才是对一个算法客观的评价。

一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

首先让我们从下面这个函数入门：
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;
	}
}
对于这个函数而言，前两个嵌套的循环总共进行了 N * N 次，第三个循环进行了 2 * N 次，最后的 while 循环进行了 10 次，那么总共的执行次数就是:

$F(N) = N^2 + 2 * N + 10$

大 O 渐进表示法

对于上述函数的执行次数： $F(N) = N^2 + 2 * N + 10$

我们发现： F (10) = 130; F(100) = 10210; F(1000) = 1002010; 随着 N 的不断变大，我们发现 F(N) 中的一些项对于最后的结果似乎影响不大，例如 2 * N 和 10 ，相对于 N ^ 2 的影响几乎可以忽略不记，因此对于上面的函数其时间复杂度为 O(N ^ 2)。

除了去掉对于结果影响不大的项，我们还要化系数为 1 ，例如：对于函数 func1 按上面的化简之后结果是 O(2 * N ^ 2 )，但是实际上称 2 * N ^ 2 与 N ^ 2 是属于同一个量级的，因此为了更加进一步化简，最终采用以下推导大O阶的方法：

1、用常数1取代运行时间中的所有加法常数。

2、在修改后的运行次数函数中，只保留最高阶项。

3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

练习

void Func2(int N)
{
     int count = 0;
     for (int k = 0; k < 2 * N ; ++ k)
     {
         ++count;
     }
     int M = 10;
     while (M--)
     {
         ++count;
     }
     printf("%d\n", count);
}
Func2 基本操作执行了 2 * N + 10 次，通过推导大O阶方法知道，时间复杂度为 O(N)
void Func3(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);
}
Func3 基本操作执行了 M + N次，有两个未知数 M 和 N ，时间复杂度为 O(N+M)
void Func4(int N)
{
     int count = 0;
     for (int k = 0; k < 10000000; ++ k)
     {
         ++count;
     }
     printf("%d\n", count);
}
Func4 基本操作执行了 10000000 次，即使看似很多，但是根据推导第一条常数化为 1 ，时间复杂度为 O(1)

PS：时间复杂度 O(1)意思为进行常数次操作，由于 CPU 运行速度已经很快，因此对于常数次基本可以忽略。
void BubbleSort(int* a, int n)
{
     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)
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 - 1;
		else
			return mid;
	}
	return -1;
}
二分查找法基本操作执行最好 1 次，最坏 logN 次，时间复杂度为 O(logN)

PS：logN 在算法分析中表示是底数为 2 ，对数为 N 。有些地方会写成 lgN。
long long Fac(size_t N)
{
     if(0 == N)
     return 1;
     return Fac(N-1)*N;
}
阶乘的递归求解，基本操作递归了N次，时间复杂度为O(N)。
long long Fib(size_t N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}
斐波那契数列的递归求解，基本操作递归了 2 ^ N 次，时间复杂度为 O(2^N)。

空间复杂度

空间复杂度概念

空间复杂度也是一个数学表达式，是一个算法在运行过程中临时占用存储空间大小的量度。

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

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

练习

void BubbleSort(int* a, int n)
{
     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;
     }
}

冒泡排序使用了常数个额外空间，所以空间复杂度为 O(1)

// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
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;
}

斐波那契数列前n项需要开辟了N个空间，空间复杂度为 O(N)

long long Fib(size_t N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}

递归求阶乘调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为 O(N)

是小黄呀~

关注

11
点赞
踩
9

收藏

觉得还不错? 一键收藏
8
评论
【数据结构与算法】时间复杂度与空间复杂度（大O渐进表示法）

文者执笔，武者持矛，程序猿的武器则是数据结构和算法。很多同学可能学了C语言好像没有什么用，还是有很多题目不会写，这就和数据结构和算法有关系。只有学好数据结构和算法，才能真正意义上的迈入计算机编程的大门！
复制链接

扫一扫