0-时间复杂度&空间复杂度的计算

         0-时间复杂度&空间复杂度的计算

*时间复杂度
时间复杂度实际就是函数，函数计算执行的基本操作次数。 ps:这里的函数是指数学里面的函数，而不是C语法里的函数。

void Test1(int N)
{
	for (int i = 0; i < N; ++i)          
	{
		for (int j = 0; j < N; ++j)                   
		{                              
			//...                   
		}         
	}           
	for (int k = 0; k < 2 * N ; ++ k)          
	{                    
		//...          
	}		
	int count = 10;           
	while (count--)          
	{                    
		//...          
	}
}

时间复杂度函数--> F(N) = N^2 + 2N + 10 这个函数计算的就是运算次数。
*算法分析的分类
     1. 最坏情况：任意输入规模的最大运行时间。（上界） 

     2. 平均情况：任意输入规模的期望运行时间。 

     3. 最好情况：任意输入规模的最小运行时间，通常最好情况不会出现。（下界）
例如：在一个长度为N的线性表中搜索一个数据x。 最坏情况:N次比较。 平均情况:N/2次比较。 最好情况:1次比较。
在实际中我们通常情况考量的是算法的最坏运行情况。也就是说对于任意输入规模N，算法的最长运行时间，理由如下：
     1. 一个算法的最坏情况的运行时间是在任意输入下的运行时间上界。

     2. 对于某些算法，最坏的情况出现的较为频繁。 

     3. 大体上看，平均情况与最坏情况一样差。
*算法分析要保持大局观：
     1. 忽略掉那些的常数。 

     2. 关注运行时间的增长趋势，关注函数式中增长最快的表达式。
O的渐进表示法（Big O Notation）
通常我们使用O记号法表示最坏运行情况的渐进上界。其实也就是说我们使用O标记法表示时间复杂度，一般关注的是算法运行的最坏情 况。
下面我们使用大O的渐进表示法计算下面函数的时间复杂度
如：F(N) = N^3 + N^2 + N +1000,则关注N^3->O(N^3)
【1.一般算法的时间复杂度计算】

void Test1(int N)
{
	for (int i = 0; i < N; ++i)          
	{
		for (int j = 0; j < N; ++j)                   
		{                              
			//...                   
		}          
	}
			
	for (int k = 0; k < 2 * N; ++k)          
	{                    
		//...          
	}
				
	int count = 10;           
	while (count--)          
	{                   
		//...          
	} 
} 

.Test1的时间复杂度为：O(N^2)

void Test2(int N, int M) 
{
	for (int i = 0; i < M; ++i)          
	{}
	for (int k = 0; k < N; ++k)
	{                    
		//...          
	} 
} 

.Test2的时间复杂度为：O(M+N)

void Test3(int N, int M) 
{
	for (int i = 0; i < M; ++i)          
	{
		for (int j = 0; j < N; ++j)                   
		{                              
			//...                   
		}          
	} 
} 

.Test3的时间复杂度为：O(M*N)
【2.分治算法的时间复杂度计算】

【3.递归算法的时间复杂度计算】
递归算法的时间复杂度为递归总次数*每次递归次数。
空间复杂度
空间复杂度的计算跟时间复杂度类似，也使用大O的渐进表示法。--（对象的个数） 要注意的是递归算法的空间复杂度，假如递归深度为N*每次递归的空间大小，如果每次递归的空间为常数，则空间复杂度为O(N)。
以斐波那契数列学习时间复杂度&空间复杂度的计算

这个数列出自赫赫有名的大作《计算之书》(没有维基百科),后来就被广泛应用于各种场合了，这个数列是这么定义的。

long long Fibonacci1(int n) 
{
	return n < 2 ? n : Fibonacci(n - 1) + Fibonacci(n - 2); 
}

斐波那契递归算法时间复杂度：O（2^N）空间复杂度为:O(N)
实现斐波那契数列 升级版1: 要求时间复杂度为O(N)。 升级版2：要求时间复杂复杂度为O(N)，空间复杂度为O(1)。
斐波那契的优化

long long* Fibonacci2(int n) 
{
	long long * fibArray = new long long[n + 1];          
	fibArray[0] = 0;           
	fibArray[1] = 1;
	for (int i = 2; i <= n; ++i)          
	{ 
		fibArray[i] = fibArray[i - 1] + fibArray[i - 2]; 
	}
	return fibArray;
} 
long long Fibonacci3(int n) 
{
	long long fibArray[3] = { 0, 1, n };
	for (int i = 2; i <= n; ++i)          
	{ 
		fibArray[2] = fibArray[1] + fibArray[0];                   
		fibArray[0] = fibArray[1];                    
		fibArray[1] = fibArray[2]; 
	}
	return fibArray[2];
}

【扩展--斐波那契那些事】

点击打开链接

时间复杂度的比较