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];
}

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

點擊打開鏈接

時間複雜度的比較