数据结构复杂度

一. 数据结构前言

1.1 数据结构

什么是数据结构呢？打开一个人的主页，有很多视频，这是数据（杂乱无章）。从上到下按照顺序整齐排列，这是在管理这些视频，即结构。

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

没有一种单一的数据结构对所有用途都有用，所以我们要学各式各样的数据结构，如：线性表、树、图、哈希等

1.2 算法

对数据进行 增删查改 就是计算，算法就是定义良好的计算过程。

数据结构和算法不分家。数据结构是载体，算法是工具（让我们可以更好地从载体里面取数据）

二. 算法效率

在下面的案例中，运行（调试）成功，但是提交失败了。失败原因是：超出时间限制。这就涉及到效率问题了。

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

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。（现在不太关注空间复杂度，因为如今的计算机储存容量很高）

2.1 时间复杂度

2.1.1 T(N)函数式

定义：在计算机科学中，算法的时间复杂度是一个函数式T(N)，它定量描述了该算法的运行时间。

那为什么不能直接计算程序的运行时间，而要用时间复杂度来衡量程序的时间效率呢？

1.因为程序运行时间和编译环境 ,运行机器的配置都有关系，
(1)同一个算法程序，老编译器和新编译器都进行编译，在同样机器下运行时间不同；同一个算法程序，用一个低配置机器和高配置机器，运行时间也不同。

2.时间只能程序写好后测试，不能在写程序之前，通过理论思想计算评估。

T(N)函数式是用来计算程序的执行次数，假设每句指令执行时间基本一样，那么执行次数和运行时间(总时间)成等比正相关。这样就可以脱离具体的编译运行环境，使得执行次数就可以代表程序时间效率的优劣。

例一：

总共执行了T(N)=N ^ 2+2N+10次。

2.1.2 大O的渐进表示法

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

推导大O阶规则

1.时间复杂度函数T(N)中，只保留最高阶项。（当N趋近于无穷时，低阶项影响很小）
2.如果最高阶不是常数，则去掉最高阶的系数。（当N趋近于无穷时，系数影响很小）
3.如果T(N)中只有常数项，则用常数1取代所有加法常数。O(1)

根据上面的规则，例一的时间复杂度是O(1)。

例二：

1）若要查找的字符在字符串第一个位置，则：T (N) = 1
2）若要查找的字符在字符串最后一个位置，则：T (N) = N
3)若要查找的字符在字符串第一个中间位置，则：T (N) = 1/2N [去掉系数]

所以，strchr的时间复杂度分为：最好的情况O(1),中间的情况O(N),最坏的情况O(2)

例三：

T(N)=100，如果T(N)中只有常数项，则用常数1取代所有加法常数，所以Func2的时间复杂度为： O(1）。

例四：

void BubbleSort(int* a, int n)
{
	assert(a);
	for (int end = n; end > 0; --end)
	{
		int exchange = 0;
		for (int i = 1; i < end; ++i)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}

所以，BubbleSort的时间复杂度取最差情况为： O(N^2 )

例五：

void func5(int n)
{
	int cnt = 1;
	while (cnt < n)
	{
		cnt *= 2;
	}
}

当n接近无穷大时，底数的大小对结果影响不大。因此，一般情况下不管底数是多少都可以省略不写，即可以表示为 log n【所以：func5的时间复杂度取最差情况为：O(log n)】

例六：

但并不是递归n次复杂度就是O(1)，因为调用一次函数，它里面可能有循环，导致单次递归的时间复杂度不是O(1).

2.2 空间复杂度

空间复杂度不是程序占用了多少bytes的空间，因为常规情况每个对象大小差异不会很大，所以空间复杂度算的是变量的个数。

空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。

编译期间已经申请好的栈空间不用计算，空间复杂度主要通过（函数在运行时显示申请的额外空间）来确定。【栈空间：存储参数、局部变量、一些寄存器信息】

例一：

// 计算BubbleSort的空间复杂度？
void BubbleSort(int* a, int n)
{
	assert(a);  //断言不需要额外申请空间
	for (int end = n; end > 0; --end)
	{    //end一次
		int exchange = 0;  //exchange一次  
		for (int i = 1; i < end; ++i)
		{      i一次
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		if (exchange == 0)
			break;
	}
}

函数栈帧在编译期间已经确定好了，只需要关注函数在运行时额外申请的空间。

BubbleSort额外申请的空间有exchange等有限个局部变量，使用了3个额外空间，因此空间复杂度为 O(1)

例二：

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

第一个函数栈帧Fac(N)在编译期间已经确定了，后面的Fac(N-1)到Fac(0)是在运行时才确定的。

Fac递归调用了N次，额外开辟了N个函数栈帧，每个栈帧使用了常数个空间
因此空间复杂度为： O(N)

2.3 常见复杂度比较

2.3 复杂度算法题

之前是循环K次将数组所有元素向后移动一位，时间复杂度不通过。O(N^2)

1.

申请新数组空间，先将后k个数据放到新数组中，再将剩下的数据挪到新数组中

void rotate(int* nums, int numsSize, int k)
{
	int newArr[numsSize];
	for (int i = 0; i < numsSize; ++i)
	{
		newArr[(i + k) % numsSize] = nums[i];
	}
	for (int i = 0; i < numsSize; ++i)
	{
		nums[i] = newArr[i];
	}
}

2.

void reverse(int* nums, int begin, int end)
{
	while (begin < end) {
		int tmp = nums[begin];
		nums[begin] = nums[end];
		nums[end] = tmp;
		begin++;
		end--;
	}
}
void rotate(int* nums, int numsSize, int k)
{
	k = k % numsSize;
	reverse(nums, 0, numsSize - k - 1);
	reverse(nums, numsSize - k, numsSize - 1);
	reverse(nums, 0, numsSize - 1);
}