数据结构初阶：时间复杂度和空间复杂度——4.9学习记录

本文链接：https://blog.youkuaiyun.com/m0_73904415/article/details/134473962

文章目录

前言
一、时间复杂度
1.大O的渐进表示法
2.时间复杂度实例
二、空间复杂度
1.概念及注意
2.空间复杂度实例
总结

前言

由数据结构引出时间复杂度和空间复杂度。

数据结构本质：在内存中管理数据——增删查改

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

一、时间复杂度

时间复杂度指基本操作的执行次数

1.大O的渐进表示法

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

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

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

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

在最终的函数表达式里，随着N的逐渐增大，后面的项对整体的影响越来越小，所以忽略不计，只计算它的量级

2.时间复杂度实例

//求其时间复杂度
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;
	}
}

其基本操作执行次数为F(N)=N^2+N+10

使用大O渐进表示法后，去除低阶项为O（N^2)

// 计算Func4的时间复杂度？
void Func4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}
	printf("%d\n", count);
}

值得注意的是，这个时间复杂度为O(1)，只要是常数次就是O（1），对于电脑来说十次和一百万次基本没啥差别，所以只要是常数次就是O(1)。

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

其运行次数是2N，使用大O渐进表示法后，去除前面的系数为O(N)

const char* strchr(const char* str, int character)
{
	while (*str)
	{
		if (*str == character)
		{
			return str;
		}

		else
			str++;
	}
}

这个函数的时间复杂度在不同情况下不同

有些算法的时间复杂度存在最好、平均和最坏情况：

最坏情况：任意输入规模的最大运行次数 ( 上界 )

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数 ( 下界 )

例如：在一个长度为 N 数组中搜索一个数据 x

最好情况： 1 次找到

最坏情况： N 次找到

平均情况： N/2 次找到

在实际中一般情况关注的是算法的最坏运行情况

// 计算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-1，之后每次冒泡次数少1，是等差数列，最后O(N^2)

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

故为O(logN)

看上去很厉害，实际上很少使用，因为前提有序

这个递归像是一个三角形，但是因为到了2就不继续下去了，所以右边阴影部分是缺少的，但是仍近似认为是满的

二、空间复杂度

1.概念及注意

空间复杂度没有时间复杂度重要，因为现在电脑的内存是相当大的，所以在做题时一般对空间复杂度没要求，甚至我们经常会使用拿时间换空间的方法做题

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

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

2.空间复杂度实例

// 计算BubbleSort的空间复杂度？
//O(1)
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;
	}
}

如冒泡排序，计算空间复杂度时就不计算已经开好的数组的大小，只将函数中临时占用的变量算进去