复杂度分析之大O表示法。

1、概要。
好的程序设计表现出程序执行速度快，占用内存空间小的优点，分别对应时间复杂度和空间复杂度。
2、复杂度分类两种。
算法的时间复杂度是指算法需要消耗的时间资源。算法执行时间的增长率与f(n) 的增长率正相关，称作渐近时间复杂度（Asymptotic Time Complexity），简称时间复杂度。定义为T(n) = O(f(n))，称函数T(n)以f(n)为界或者称T(n)受限于f(n)。
算法的空间复杂度是指算法需要消耗的空间资源。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。

常见的算法时间复杂度由小到大依次为：
O(1) 常数阶
O(logn) 对数阶
O(n) 线性阶
O(n*logn) 线性对数阶
O(n^2) 平方阶
O(n^k) K方阶
O(2^n) 指数阶
O(n!) 阶乘阶
…
其中，O(2^n) 和O(n!)为非多项式量级，NP（Non-Deterministic Polynomial，非确定多项式）问题，其复杂度计算机往往不能承受的。除此二者，都是多项式量级。

图表来源：https://www.bigocheatsheet.com

3、时间复杂度。
3.1辨识要素及示例。

int CalcSum(int n)
{
	int sum = 0;

	for (int i = 0; i < n; i++)
	{
		sum += i;
	}

	return sum;
}

Demo求累加和，假设每条语句执行时间为time，容易算出来该函数运行时间为：T(n) = time+time+ntime2 = 2*(n+1)*time。用f(n)来表示代码的执行次数和数据规模的关系，即f(n)=2n+2。f(n)中的常数项对于整个公式的值的影响我们直接忽略，同样，我们也忽略系数。即得：f(n) = n；代入T(n) = O(f(n))，得：T(n) = O(n)，线性阶。

①、只关注循环执行次数最多的一段代码；

int CalcSum(int n)
{
	int sum1 = 0;
	int sum2 = 0;

	for (int i = 0; i < n; i++)
	{
		sum1 += i;
	}

	for (int j = 0; j < n * 2; j++)
	{
		sum2 += j;
	}

	return sum1 + sum2;
}

容易看出来循环二比循环一的执行次数多，因此只需要关注循环二，得到T(n) = O(n);线性阶。
②、加法法则：总复杂度等于量级最大的那段代码的复杂度；

int CalcSum(int n)
{
	int sum1 = 0;
	int sum2 = 0;
	int sum3 = 0;


	for (int i = 0; i < 100; i++)
	{
		sum1 += i;
	}

	for (int j = 0; j < n; j++)
	{
		sum2 += j;
	}

	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			sum3 += j;
		}
	}

	return sum1 + sum2 + sum3;
}

容易得到循环一二三的时间复杂度分别为：O(1) （常数阶），O(n)（线性阶），O(n^2)（平方阶）；则T(n) = O(1)+O(n)+O(n^2);按照加法原则，总复杂度等于量级最大的那段代码的复杂度。即T(n) = O(n^2)，平方阶。
③、乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积。

int CalcSum(int n)
{
	int sum = 0;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			sum += j;
		}
	}
	return sum;
}

嵌套循环 = 外层内层。即T(n) = O(nn) = O(n^2)，平方阶。
Ps：
对数阶：

int CalcSum(int n)
{
	int sum = 0;
	int i = 1;
	do
	{
		i = i * 2;
		sum += i;
	} while (i < n);
	return sum;
}

在while循环里面，每次都将 i 乘以 2翻倍，距离n越来越近。循环x次后，退出，也就是说2^x >=n。那么x = log2n（以2为底，n的对数）。这就是对数阶，时间复杂度为：T(n) = O(logn)。
线性对数阶：
将对数阶循环n遍，就是线性对数阶。即：T(n) = n*(O(logn)) = O(n*logn)。
3.2时间复杂度三种类别。
时间复杂度里细分起来又有最好、最坏、平均情况时间复杂度之分：
1、最好情况时间复杂度就是在最理想的情况下，执行这段代码的时间复杂度；
2、最坏情况时间复杂度就是在最糟糕的情况下，执行这段代码的时间复杂度；
3、平均情况时间复杂度顾名思义就是结合概率论分析从最好到最坏每种情况平均下来的加权平均时间复杂度。

图表来源：https://www.bigocheatsheet.com
4、空间复杂度。
空间复杂度比较常用的有：O(1)、O(n)、O(n²)。
4.1 S(n) = O(1).
不存在存储空间随变量变化情况。

void GetSpace(int n)
{
	vector<int> array;
	array.push_back(1);
	array.push_back(2);
	array.push_back(3);
	array.push_back(4);
	array.push_back(5);

	int sum = 0;
	for (auto it:array)
	{
		sum += it;
	}
}

4.2 S(n) = O(n).
例程中，申请空间后，没有在申请其他空间。复杂度为：O(n)。

void GetSpace(int n)
{
	int* p = new int[n];
	int sum = 0;
	for (int i = 0; i <= n; ++i)
	{
		sum += i;
	}
}

5、 总结
①、算法的速度并非指时间，不是以秒为单位；而是操作数的增速。从增量的角度度量的。
②、平时说算法的速度，指的是随着输入的增加，其运行时间将会以什么样的速度进行增加。
③、算法运行时间用大O表示法表示。
④、 O(㏒n)比O(n)快。当操作的元素规模差距越大，快的越明显。