【数据结构】复杂度讲解

EnticE152

已于 2023-10-05 06:55:28 修改

阅读量1k

点赞数 5

文章标签：数据结构

于 2023-02-10 21:18:00 首次发布

本文链接：https://blog.csdn.net/qq_66767938/article/details/128926016

版权

时间复杂度与空间复杂度：：

什么是数据结构?

数据结构是计算机存储,组织数据的方式,指相互之间存在一种或多种特定关系的数据元素的集合.

什么是算法？

算法是定义良好的计算过程,它取一个或一组的值为输入,并产生一个或一组值作为输出.简单来说
算法就是一系列的计算步骤,用来将输入数据转化成输出结果.

例如：数据结构是在内存中管理数据——增删查改
数据库是在磁盘中管理数据——增删查改

1.算法效率

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源,因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度.
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间，在计算机发展的早期，计算机的存储容量很小，所以对空间复杂度很是在乎，但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度，所以我们如今已经不需要再特别关注一个算法的空间复杂度.
摩尔定律：集成电路上可以容纳的晶体管数目在大约每经过18个月便会增加一倍.

2.时间复杂度

时间复杂度的概念：

时间复杂度的定义：在计算机科学中,算法的时间复杂度是一个函数，它定量描述了该算法的运行时间，一个算法执行所耗费的时间，从理论上来说是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道，但是我们需要每个算法都上机测试吗?是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式，一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作执行次数，为算法的时间复杂度，即：找到某条语句与问题规模N之间的数学表达式,就是算出了该算法的时间复杂度.

void Func1(int N)
{
	int count = 0;
	for (int i = 0; i < N; ++i)
	{
		for (int j = 0; j < N; ++i)
		{
			++count;
		}
	}
	for (int k = 0; k < 2 * N; ++k)
	{
		++count;
	}
	int M = 10;
	while (M--)
	{
		++count;
	}
	printf("%d\n", count);
}
//时间复杂度为:O(N^2)
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);
}
//时间复杂度为: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);
}
//时间复杂度为:O(M+N)
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(N^2)
void Fun4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}
	printf("%d\n", count);
}
//时间复杂度为:O(1)

大O的渐进表示法：
大O符号是用于描述函数渐进行为的数学符号.
推导大O渐进表示法：
1.用常数1取代运行时间中的所有加法常数.
2.在修改后的运行次数函数中，只保留最高阶项.
3.如果最高阶系数存在且不是1，则去掉与这个项目相乘的常数，得到的结果就是大O阶.

算法的时间复杂度存在最好,最坏和平均情况：
最坏情况:任意输入规模的最大运行次数(上界)
平均情况:任意输入规模的期望运行次数
最好情况:任意输入规模的最小运行次数(下界)
例如:在一个长度为N的数组中搜索一个数据x
最好情况:1次找到
最坏情况:N次找到
平均情况:N/2次找到
在实际情况中关注的是算法的最坏运行情况,所以数组中搜索数据时间复杂度为O(N)

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(1)
//二分查找的最坏情况是找不到 时间复杂度为O(logN)
//每查找一次 查找区间个数减少一半(除2)
//N/2/2/2.../2 = 1
longlong Fac(size_t N)
{
	if (1 == N)
		return 1;
	return Fac(N - 1) * N;
}
//时间复杂度为O(N)
longlong Fib(size_t N)
{
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
}
//时间复杂度为O(2^N)
longlong Fib(size_t N)
{
	if (N < 3)
		return 1;
	longlong f1 = 1, f2 = 1, f3;
	for (size_t i = 3; i <= N; ++i)
	{
		f3 = f2 + f1;
		f1 = f2;
		f2 = f3;
	}
	return f3;
}
//时间复杂度为O(N)

3.空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中额外占用存储空间大小的量度.
空间复杂度不是程序占用了多少字节的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数.
空间复杂度计算规则基本跟时间复杂度类似，也使用大O的渐进表示法.
注意：函数运行时所需要的栈空间(存储参数,局部变量,一些寄存器信息等)在编译期间已经确定好了,因此空间复杂度主要通过函数在运行时侯显示申请的额外空间来确定.
1G大约10亿字节 1G = 1024*1024*1024
1M大约100万字节 1M = 1024*1024

//计算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)
//计算Fac的空间复杂度
longlong Fac(size_t N)
{
	if (N == 0)
		return 1;
	return Fac(N - 1) * N;
}
//空间复杂度为O(N)
//每个函数栈帧是常数个 有N+1个Fac栈帧
//迭代求解斐波那契数列的空间复杂度为O(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;
}
//计算Fib的空间复杂度
longlong Fib(size_t N)
{
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
}
//空间复杂度为O(N)

4.常见时间复杂度以及复杂度OJ练习

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

5201314	O(1)	常数阶
3n+4	O(n)	线性阶
3n^2+4n+5	O(n^2)	平方阶
3log(2)n+4	O(logn)	对数阶
2n+3nlog(2)n+14	O(n*logn)	nlogn阶
n^3+2n^2+4n+6	O(n^3)	立方阶
2^n	O(2^n)	指数阶

复杂度的OJ练习：

消失的数字：

轮转数组：

//思路一:
int missingNumber(int* nums, int numsSize)
{
	int sum1 = 0;
	int sum2 = 0;
	int i = 0;
	//求数组nums的数字之和
	for (i = 0; i < numsSize; i++)
	{
		sum1 += nums[i];
	}
	for (i = 0; i < numsSize + 1; i++)
	{
		sum2 += i;
	}
	return sum2 - sum1;
}
//思路二:
int missingNumber(int* nums, int numSize)
{
	int x = 0;
	int i = 0;
	for (i = 0; i < numSize; i++)
	{
		x ^= nums[i];
	}
	int j = 0;
	for (j = 0; i < numSize + 1; j++)
	{
		x ^= j;
	}
	return x;
}

轮转数组：

//思路一:
void rotate(int* nums, int numsSize, int k)
{
      int i = 0;
	  k %= numsSize;
	  for (i = 0; i < k; i++)
      {
		    int tmp = nums[numsSize - 1];
		    int j = 0;
		    for (j = numsSize - 1; j > 0; j--)
		    {
			      nums[j] = nums[j - 1];
		    }
		  nums[0] = tmp;
  	 }
}
//思路二:
void reverse(int* a, int begin, int end)
{
	while (begin < end)
	{
		int tmp = a[begin];
		a[begin] = a[end];
		a[end] = tmp;
		begin++;
		end--;
	}
}
void rotate(int* nums, int numsSize, int k)
{
	k %= numsSize;
	reverse(nums, 0, numsSize - k - 1);
	reverse(nums, numsSize - k, numsSize - 1);
	reverse(nums, 0, numsSize - 1);
}
//思路三:以空间换时间
void rotate(int* nums, int numsSize, int k)
{
	k %= numsSize;
	int* tmp = (int*)malloc(sizeof(int) * numsSize);
	int i = 0;
	int j = numsSize - k;
	for (j = numsSize - k; j < numsSize; j++)
	{
		tmp[i++] = nums[j];
	}
	for (j = 0; j < numsSize - k; j++)
	{
		tmp[i++] = nums[j];
	}
	for (i = 0; i < numsSize; i++)
	{
		nums[i] = tmp[i];
	}
	free(tmp);
	tmp = NULL;
}