数据结构——A/复杂度_问题a 复杂度分析csdn-CSDN博客

本文围绕数据结构和算法展开，先介绍了数据结构和算法的概念、学习方法及相关书籍资料。重点阐述算法复杂度，包括时间复杂度的概念、大O渐进表示法及常见计算实例，如O(N)、O(N^2)等；还介绍了空间复杂度的计算规则和实例，最后给出复杂度的OJ练习链接。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

🌈个人主页：慢了半拍

🔥 创作专栏：《史上最强算法分析》 | 《无味生》 |《史上最强C语言讲解》 | 《史上最强C练习解析》|《史上最强数据结构》 |

🏆我的格言：一切只是时间问题。

基础铺垫

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

2.什么是算法？
算法(Algorithm)：就是一系列的计算步骤，用来将输入数据转化成输出结果。

3.怎么学好算法

a.死磕代码；
b.注意画图和思考。

4.数据结构和算法书籍及资料推荐

a.刷题《剑指offer》和《程序员代码面试指南》； b.做补充C语言版本严蔚敏、CPP殷人昆、看图《大话数据结构》；
c.刷完上面的内容，我们童鞋还可以去刷刷 Leetcode。

5.数据结构三要素

a. 逻辑结构：集合、线性结构（一对一）、树形结构（一对多）、图结构或网状结构（多对多）；

b. 数据运算；

c. 物理结构(存储结构）：顺序储存，非顺序储存（链式、索引、数列储存）。

一、算法效率

如何衡量一个算法的好坏呢？答：算法的复杂度

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。

二、时间复杂度

2.1 概念

定义：在计算机科学中，算法的时间复杂度是一个函数，算法中的基本操作的执行次数，为算法的时间复杂度。
即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

2.2 大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。

另外有些算法的时间复杂度存在最好、平均和最坏情况：
1、最坏情况：任意输入规模的最大运行次数(上界)
2、平均情况：任意输入规模的期望运行次数
3、最好情况：任意输入规模的最小运行次数(下界)

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

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

实例1：O(N)

//实例1
// 计算Func1的时间复杂度？
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);
}

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

实例2：O(N+M)

//实例2
// 计算Func2的时间复杂度？
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);
}

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

实例3：O(N)

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


//等同于
while (*str)//遇到/0 为假跳出循环
{
	if (*str == character)
		return str;
	else
		++str;
}

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

实例4：O(N^2)

//实例4
// 计算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;
	}
}

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

实例5：O(logN)

//实例5
// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
	assert(a);
	int begin = 0;
	int end = n - 1;
	// [begin, end]：begin和end是左闭右闭区间，因此有=号
	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;
}

实例5：基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN) ps：logN在算法分析中表示是底数为2，对数为N。有些地方会写成lgN。（建议通过折纸查找的方式讲解logN是怎么计算出来的）

总结：时间复杂度：冒泡排序：O(N^2) ；快排：O(N*logN)。

实例6：O(N)

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


//推广
long long Fac(size_t N)
{
	if (0 == N)
		return 1;
    for(size_t i = 0; i < N; ++i)
    {
    //其他

    }
	return Fac(N - 1) * N;
}

实例6：通过计算分析发现基本操作递归了N次，时间复杂度为O(N)；

推广：通过计算分析发现基本操作递归了N次，并且中间嵌套循环N次，时间复杂度为O(N^2)。

实例7：O(2^N)

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

实例7：通过计算分析发现基本操作递归了2^N次，时间复杂度为O(2^N)。

三、空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度。
空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

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

实例1：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;
	}
}

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

实例2：O(N)

//计算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个空间，空间复杂度为 O(N)

实例3：O(N)

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

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

四、常见复杂度对比

常数阶	122345	O(1)
线性阶	2n+1	O(N)
平方阶	3n^2+1	O(N^2)
对数阶	3log(2)n+4	O(log N )
nlong阶	3nlog(2)n+4	O(N log N)
立方阶	n^3+n^2+1	O(N^3)
指数阶	2^n	O(2^N)