線性選擇演算法時間復雜度

❶ 在任意一個基本線性表中插入一個新結點的演算法時間復雜度是都是相等的嘛

一個演算法有最好、平均、最壞時間復雜度。比如直接插入法的時間復雜度在最好情況（線性表有序）下是O(n)，最壞和平均是都是O(n^2)。

一般情況下，如果沒有特別指出，時間復雜度都是指平均時間復雜度。
所以如果是相同演算法，一般語境下時間復雜度是相等的。

❷ 演算法的時間復雜度是什麼

演算法的時間復雜度，是一個用於度量一個演算法的運算時間的一個描述，本質是一個函數。

根據這個函數能在不用具體的測試數據來測試的情況下，粗略地估計演算法的執行效率，換句話講時間復雜度表示的只是代碼執行時間隨數據規模增長的變化趨勢。

常用大O來表述，這個函數描述了演算法執行所要時間的增長速度，記作f(n)。演算法需要執行的運算次數（用函數表示）記作T(n)。存在常數 c 和函數 f(n)，使得當 n >= c 時 T(n) <= f(n)，記作 T(n) = O(f(n))，其中，n代表數據規模也就是輸入的數據。

時間復雜度如何計算

1、常量階：只要代碼的執行時間不隨 n 的增大而增長，這樣代碼的時間復雜度都記作 O(1)。或者說，一般情況下，只要演算法中不存在循環語句、遞歸語句，即使有成千上萬行的代碼，其時間復雜度也是Ο(1)。

2、線性階、n方階：一般情況下，如果循環體內循環控制變數為線性增長，那麼包含該循環的演算法的時間復雜度為O(n)，線性階嵌套線性階的演算法時間復雜度為O(nⁿ)，涉及下文乘法法則。

3、線性對數階：當一個線性階代碼段法嵌套一個對數階代碼段，該演算法的時間復雜度為O(nlogn)。

4、指數階和階乘階：根據函數，隨著n的增加，運行時間會無限急劇增加，因此效率非常低下。

❸ 如何分析時間復雜度(線性表)

演算法分析

同一問題可用不同演算法解決，而一個演算法的質量優劣將影響到演算法乃至程序的效率。演算法分析的目的在於選擇合適演算法和改進演算法。一個演算法的評價主要從時間復雜度和空間復雜度來考慮。

1、時間復雜度

（1）時間頻度

一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。

（2）時間復雜度

在剛才提到的時間頻度中，n稱為問題的規模，當n不斷變化時，時間頻度T(n)也會不斷變化。但有時我們想知道它變化時呈現什麼規律。為此，我們引入時間復雜度概念。

一般情況下，演算法中基本操作重復執行的次數是問題規模n的某個函數，用T(n)表示，若有某個輔助函數f(n),使得當n趨近於無窮大時，T（n)/f(n)的極限值為不等於零的常數，則稱f(n)是T(n)的同數量級函數。記作T(n)=O(f(n)),稱O(f(n)) 為演算法的漸進時間復雜度，簡稱時間復雜度。

在各種不同演算法中，若演算法中語句執行次數為一個常數，則時間復雜度為O(1),另外，在時間頻度不相同時，時間復雜度有可能相同，如T(n)=n2+3n+4與T(n)=4n2+2n+1它們的頻度不同，但時間復雜度相同，都為O(n2)。

按數量級遞增排列，常見的時間復雜度有：

常數階O(1),對數階O(log2n),線性階O(n),

線性對數階O(nlog2n),平方階O(n2)，立方階O(n3),...，

k次方階O(nk),指數階O(2n)。隨著問題規模n的不斷增大，上述時間復雜度不斷增大，演算法的執行效率越低。

2、空間復雜度

與時間復雜度類似，空間復雜度是指演算法在計算機內執行時所需存儲空間的度量。記作:

S(n)=O(f(n))

我們一般所討論的是除正常佔用內存開銷外的輔助存儲單元規模。

❹ 排序演算法的時間復雜度如何

排序演算法的時間復雜度是若文件的初始狀態是正序的，一趟掃描即可完成排序。

比較是相鄰的兩個元素比較，交換也發生在這兩個元素之間。所以，如果兩個元素相等，是不會再交換的；如果兩個相等的元素沒有相鄰，那麼即使通過前面的兩兩交換把兩個相鄰起來，這時候也不會交換，所以相同元素的前後順序並沒有改變，所以冒泡排序是一種穩定排序演算法。

次線性時間

對於一個演算法，若其匹配T(n) = o(n)，則其時間復雜度為次線性時間（sub-linear time或sublinear time）。實際上除了匹配以上定義的演算法，其他一些演算法也擁有次線性時間的時間復雜度。例如有O(n)葛羅佛搜索演算法。

常見的非合次線性時間演算法都採用了諸如平行處理（就像NC1matrix行列式計算那樣）、非古典處理（如同葛羅佛搜索那樣），又或者選擇性地對有保證的輸入結構作出假設（如冪對數時間的二分搜索）。

不過，一些情況，例如在頭 log(n) 比特中每個字元串有一個比特作為索引的字元串組就可能依賴於輸入的每個比特，但又匹配次線性時間的條件。

「次線性時間演算法」通常指那些不匹配前一段的描述的演算法。它們通常運行於傳統計算機架構系列並且不容許任何對輸入的事先假設。但是它們可以是隨機化演算法，而且必須是真隨機演算法除了特殊情況。

❺ 演算法復雜度：時間復雜度和空間復雜度

本文部分摘抄於此
演算法復雜度分為時間復雜度和空間復雜度。
時間復雜度是指執行演算法所需要的計算工作量；
而空間復雜度是指執行這個演算法所需要的內存空間。
（演算法的復雜性體現在運行該演算法時的計算機所需資源的多少上，計算機資源最重要的是時間和空間（即寄存器）資源，因此復雜度分為時間和空間復雜度）。

一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。

在剛才提到的時間頻度中，n稱為問題的規模，當n不斷變化時，時間頻度T(n)也會不斷變化。但有時我們想知道它變化時呈現什麼規律。為此，我們引入時間復雜度概念。 一般情況下，演算法中基本操作重復執行的次數是問題規模n的某個函數，用T(n)表示，若有某個輔助函數f(n),使得當n趨近於無窮大時， T(n)/f(n) 的極限值為不等於零的常數，則稱f(n)是T(n)的同數量級函數。記作 T(n)=O(f(n)), 稱 O(f(n)) 為演算法的漸進時間復雜度，簡稱時間復雜度。

並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。

演算法中執行次數最多的那條語句就是基本語句，通常是最內層循環的循環體。

只需計算基本語句執行次數的數量級，這就意味著只要保證基本語句執行次數的函數中的最高次冪正確即可，可以忽略所有低次冪和最高次冪的系數。這樣能夠簡化演算法分析，並且使注意力集中在最重要的一點上：增長率。

將基本語句執行次數的數量級放入大Ο記號中。

如果演算法中包含嵌套的循環，則基本語句通常是最內層的循環體，如果演算法中包含並列的循環，則將並列循環的時間復雜度相加。

第一個for循環的時間復雜度為Ο(n)，第二個for循環的時間復雜度為Ο( n 2)，則整個演算法的時間復雜度為Ο(n+ n 2)=Ο( n 2)。

Ο(1)表示基本語句的執行次數是一個常數，一般來說，只要演算法中不存在循環語句，其時間復雜度就是Ο(1)。其中 Ο(log2n)、Ο(n)、 Ο(nlog2n)、Ο(n2)和Ο(n3) 稱為多項式時間， 而Ο(2n)和Ο(n!)稱為指數時間 。計算機科學家普遍認為前者（即多項式時間復雜度的演算法）是有效演算法，把這類問題稱為 P（Polynomial,多項式）類問題 ，而把後者（即指數時間復雜度的演算法）稱為 NP（Non-Deterministic Polynomial, 非確定多項式）問題 。

（4）在計算演算法時間復雜度時有以下幾個簡單的程序分析法則:

(1).對於一些簡單的輸入輸出語句或賦值語句,近似認為需要O(1)時間

(2).對於順序結構,需要依次執行一系列語句所用的時間可採用大O下"求和法則"

求和法則:是指若演算法的2個部分時間復雜度分別為 T1(n)=O(f(n))和 T2(n)=O(g(n)),則 T1(n)+T2(n)=O(max(f(n), g(n)))

特別地, 若T1(m)=O(f(m)), T2(n)=O(g(n)),則 T1(m)+T2(n)=O(f(m) + g(n))

(3).對於選擇結構,如if語句,它的主要時間耗費是在執行then字句或else字句所用的時間,需注意的是檢驗條件也需要O(1)時間

(4).對於循環結構,循環語句的運行時間主要體現在多次迭代中執行循環體以及檢驗循環條件的時間耗費,一般可用大O下"乘法法則"

乘法法則 : 是指若演算法的2個部分時間復雜度分別為 T1(n)=O(f(n))和 T2(n)=O(g(n)),則T1 * T2=O(f(n) * g(n))

(5).對於復雜的演算法,可以將它分成幾個容易估算的部分,然後利用求和法則和乘法法則技術整個演算法的時間復雜度

另外還有以下2個運演算法則:(1) 若g(n)=O(f(n)),則O(f(n))+ O(g(n))= O(f(n))；(2) O(Cf(n)) = O(f(n)),其中C是一個正常數

（5）下面分別對幾個常見的時間復雜度進行示例說明：

(1)、O(1)

​ Temp=i; i=j; j=temp;

以上三條單個語句的頻度均為1，該程序段的執行時間是一個與問題規模n無關的常數。演算法的時間復雜度為常數階，記作T(n)=O(1)。 注意：如果演算法的執行時間不隨著問題規模n的增加而增長，即使演算法中有上千條語句，其執行時間也不過是一個較大的常數。此類演算法的時間復雜度是O(1)。

(2)、O(n2)

2.1. 交換i和j的內容

解： 因為Θ(2n2+n+1)=n2（Θ即：去低階項，去掉常數項，去掉高階項的常參得到），所以T(n)= =O(n2)；

2.2.

​

解： 語句1的頻度是n-1

一般情況下，對步進循環語句只需考慮循環體中語句的執行次數，忽略該語句中步長加1、終值判別、控制轉移等成分，當有若干個循環語句時，演算法的時間復雜度是由嵌套層數最多的循環語句中最內層語句的頻度f(n)決定的。

(3)、O(n)

解：

(4)、O(log2n)

解：

(5)、O(n3)

解：

（5）常用的演算法的時間復雜度和空間復雜度

一個經驗規則： 其中c是一個常量，如果一個演算法的復雜度為c 、 log2n 、n 、 n log2n ,那麼這個演算法時間效率比較高 ，如果是 2n * , 3n ,n!，那麼稍微大一些的n就會令這個演算法不能動了，居於中間的幾個則差強人意。

​ 演算法時間復雜度分析是一個很重要的問題，任何一個程序員都應該熟練掌握其概念和基本方法，而且要善於從數學層面上探尋其本質，才能准確理解其內涵。

2、演算法的空間復雜度

​ 類似於時間復雜度的討論，一個演算法的空間復雜度(Space Complexity)S(n)定義為該演算法所耗費的存儲空間，它也是問題規模n的函數。漸近空間復雜度也常常簡稱為空間復雜度。

空間復雜度(Space Complexity)是對一個演算法在運行過程中臨時佔用存儲空間大小的量度。一個演算法在計算機存儲器上所佔用的存儲空間，包括存儲演算法本身所佔用的存儲空間，演算法的輸入輸出數據所佔用的存儲空間和演算法在運行過程中臨時佔用的存儲空間這三個方面。

演算法的輸入輸出數據所佔用的存儲空間是由要解決的問題決定的，是通過參數表由調用函數傳遞而來的，它不隨本演算法的不同而改變。存儲演算法本身所佔用的存儲空間與演算法書寫的長短成正比，要壓縮這方面的存儲空間，就必須編寫出較短的演算法。

演算法在運行過程中臨時佔用的存儲空間隨演算法的不同而異，有的演算法只需要佔用少量的臨時工作單元，而且不隨問題規模的大小而改變，我們稱這種演算法是「就地"進行的，是節省存儲的演算法，如這一節介紹過的幾個演算法都是如此；

有的演算法需要佔用的臨時工作單元數與解決問題的規模n有關，它隨著n的增大而增大，當n較大時，將佔用較多的存儲單元，例如將在第九章介紹的快速排序和歸並排序演算法就屬於這種情況。

如當一個演算法的空間復雜度為一個常量，即不隨被處理數據量n的大小而改變時，可表示為O(1)；當一個演算法的空間復雜度與以2為底的n的對數成正比時，可表示為O(log2n)；當一個演算法的空I司復雜度與n成線性比例關系時，可表示為O(n).

【1】如果演算法的執行時間不隨著問題規模n的增加而增長，即使演算法中有上千條語句，其執行時間也不過是一個較大的常數。此類演算法的時間復雜度是O(1)。

解答：
T(n)=O(1)，
這個程序看起來有點嚇人，總共循環運行了1100次，但是我們看到n沒有?
沒。這段程序的運行是和n無關的，
就算它再循環一萬年，我們也不管他，只是一個常數階的函數

【2】當有若干個循環語句時，演算法的時間復雜度是由嵌套層數最多的循環語句中最內層語句的頻度f(n)決定的。

該程序段中頻度最大的語句是(5)，內循環的執行次數雖然與問題規模n沒有直接關系，但是卻與外層循環的變數取值有關，而最外層循環的次數直接與n有關，因此可以從內層循環向外層分析語句(5)的執行次數：
則該程序段的時間復雜度為T(n)=O(n3/6+低次項)=O(n3)

【3】演算法的時間復雜度不僅僅依賴於問題的規模，還與輸入實例的初始狀態有關。

在數值A[0..n-1]中查找給定值K的演算法大致如下：

此演算法中的語句(3)的頻度不僅與問題規模n有關，還與輸入實例中A的各元素取值及K的取值有關:

（5）時間復雜度評價性能

有兩個演算法A1和A2求解同一問題，時間復雜度分別是T1(n)=100n2，T2(n)=5n3。
（1）當輸入量n＜20時，有T1(n)＞T2(n)，後者花費的時間較少。
（2）隨著問題規模n的增大，兩個演算法的時間開銷之比5n3/100n2=n/20亦隨著增大。
即當問題規模較大時，演算法A1比演算法A2要有效地多。它們的漸近時間復雜度O(n2)和O(n3)從宏觀上評價了這兩個演算法在時間方面的質量。

在演算法分析時，往往對演算法的時間復雜度和漸近時間復雜度不予區分，而經常是將漸近時間復雜度T(n)=O(f(n))簡稱為時間復雜度，其中的f(n)一般是演算法中頻度最大的語句頻度。

其實生活很美好，只是你想的太多了。沒有，不會，有差距很正常，因為我不會

❻ 演算法的空間復雜度和時間復雜度的關系

論壇

活動

招聘

專題

打開CSDN APP
Copyright © 1999-2020, CSDN.NET, All Rights Reserved

搜索博文/帖子/用戶
登錄

zolalad
關注
演算法的時間復雜度和空間復雜度-總結 原創
2013-09-20 16:01:26
308點贊

zolalad

碼齡9年

關注
演算法的時間復雜度和空間復雜度-總結
通常，對於一個給定的演算法，我們要做 兩項分析。第一是從數學上證明演算法的正確性，這一步主要用到形式化證明的方法及相關推理模式，如循環不變式、數學歸納法等。而在證明演算法是正確的基礎上，第二部就是分析演算法的時間復雜度。演算法的時間復雜度反映了程序執行時間隨輸入規模增長而增長的量級，在很大程度上能很好反映出演算法的優劣與否。因此，作為程序員，掌握基本的演算法時間復雜度分析方法是很有必要的。
演算法執行時間需通過依據該演算法編制的程序在計算機上運行時所消耗的時間來度量。而度量一個程序的執行時間通常有兩種方法。

一、事後統計的方法

這種方法可行，但不是一個好的方法。該方法有兩個缺陷：一是要想對設計的演算法的運行性能進行評測，必須先依據演算法編制相應的程序並實際運行；二是所得時間的統計量依賴於計算機的硬體、軟體等環境因素，有時容易掩蓋演算法本身的優勢。

二、事前分析估算的方法

因事後統計方法更多的依賴於計算機的硬體、軟體等環境因素，有時容易掩蓋演算法本身的優劣。因此人們常常採用事前分析估算的方法。

在編寫程序前，依據統計方法對演算法進行估算。一個用高級語言編寫的程序在計算機上運行時所消耗的時間取決於下列因素：

(1). 演算法採用的策略、方法；(2). 編譯產生的代碼質量；(3). 問題的輸入規模；(4). 機器執行指令的速度。

一個演算法是由控制結構（順序、分支和循環3種）和原操作（指固有數據類型的操作）構成的，則演算法時間取決於兩者的綜合效果。為了便於比較同一個問題的不同演算法，通常的做法是，從演算法中選取一種對於所研究的問題（或演算法類型）來說是基本操作的原操作，以該基本操作的重復執行的次數作為演算法的時間量度。

1、時間復雜度
（1）時間頻度 一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
（2）時間復雜度 在剛才提到的時間頻度中，n稱為問題的規模，當n不斷變化時，時間頻度T(n)也會不斷變化。但有時我們想知道它變化時呈現什麼規律。為此，我們引入時間復雜度概念。 一般情況下，演算法中基本操作重復執行的次數是問題規模n的某個函數，用T(n)表示，若有某個輔助函數f(n),使得當n趨近於無窮大時，T(n)/f(n)的極限值為不等於零的常數，則稱f(n)是T(n)的同數量級函數。記作T(n)=O(f(n)),稱O(f(n)) 為演算法的漸進時間復雜度，簡稱時間復雜度。

另外，上面公式中用到的 Landau符號其實是由德國數論學家保羅·巴赫曼（Paul Bachmann）在其1892年的著作《解析數論》首先引入，由另一位德國數論學家艾德蒙·朗道（Edmund Landau）推廣。Landau符號的作用在於用簡單的函數來描述復雜函數行為，給出一個上或下（確）界。在計算演算法復雜度時一般只用到大O符號，Landau符號體系中的小o符號、Θ符號等等比較不常用。這里的O，最初是用大寫希臘字母，但現在都用大寫英語字母O；小o符號也是用小寫英語字母o，Θ符號則維持大寫希臘字母Θ。
T (n) = Ο(f (n)) 表示存在一個常數C，使得在當n趨於正無窮時總有 T (n) ≤ C * f(n)。簡單來說，就是T(n)在n趨於正無窮時最大也就跟f(n)差不多大。也就是說當n趨於正無窮時T (n)的上界是C * f(n)。其雖然對f(n)沒有規定，但是一般都是取盡可能簡單的函數。例如，O(2n2+n +1) = O (3n2+n+3) = O (7n2 + n) = O ( n2 ) ，一般都只用O(n2)表示就可以了。注意到大O符號里隱藏著一個常數C，所以f(n)里一般不加系數。如果把T(n)當做一棵樹，那麼O(f(n))所表達的就是樹干，只關心其中的主幹，其他的細枝末節全都拋棄不管。
在各種不同演算法中，若演算法中語句執行次數為一個常數，則時間復雜度為O(1),另外，在時間頻度不相同時，時間復雜度有可能相同，如T(n)=n2+3n+4與T(n)=4n2+2n+1它們的頻度不同，但時間復雜度相同，都為O(n2)。 按數量級遞增排列，常見的時間復雜度有：常數階O(1),對數階O(log2n),線性階O(n), 線性對數階O(nlog2n),平方階O(n2)，立方階O(n3),...， k次方階O(nk),指數階O(2n)。隨著問題規模n的不斷增大，上述時間復雜度不斷增大，演算法的執行效率越低。

從圖中可見，我們應該盡可能選用多項式階O(nk)的演算法，而不希望用指數階的演算法。

常見的演算法時間復雜度由小到大依次為：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)

一般情況下，對一個問題（或一類演算法）只需選擇一種基本操作來討論演算法的時間復雜度即可，有時也需要同時考慮幾種基本操作，甚至可以對不同的操作賦予不同的權值，以反映執行不同操作所需的相對時間，這種做法便於綜合比較解決同一問題的兩種完全不同的演算法。

（3）求解演算法的時間復雜度的具體步驟是：

⑴ 找出演算法中的基本語句；

演算法中執行次數最多的那條語句就是基本語句，通常是最內層循環的循環體。

⑵ 計算基本語句的執行次數的數量級；

只需計算基本語句執行次數的數量級，這就意味著只要保證基本語句執行次數的函數中的最高次冪正確即可，可以忽略所有低次冪和最高次冪的系數。這樣能夠簡化演算法分析，並且使注意力集中在最重要的一點上：增長率。

⑶ 用大Ο記號表示演算法的時間性能。

將基本語句執行次數的數量級放入大Ο記號中。

如果演算法中包含嵌套的循環，則基本語句通常是最內層的循環體，如果演算法中包含並列的循環，則將並列循環的時間復雜度相加。例如：

for (i=1; i<=n; i++)
x++;
for (i=1; i<=n; i++)
for (j=1; j<=n; j++)
x++;
第一個for循環的時間復雜度為Ο(n)，第二個for循環的時間復雜度為Ο(n2)，則整個演算法的時間復雜度為Ο(n+n2)=Ο(n2)。

Ο(1)表示基本語句的執行次數是一個常數，一般來說，只要演算法中不存在循環語句，其時間復雜度就是Ο(1)。其中Ο(log2n)、Ο(n)、 Ο(nlog2n)、Ο(n2)和Ο(n3)稱為多項式時間，而Ο(2n)和Ο(n!)稱為指數時間。計算機科學家普遍認為前者（即多項式時間復雜度的演算法）是有效演算法，把這類問題稱為P（Polynomial,多項式）類問題，而把後者（即指數時間復雜度的演算法）稱為NP（Non-Deterministic Polynomial, 非確定多項式）問題。

一般來說多項式級的復雜度是可以接受的，很多問題都有多項式級的解——也就是說，這樣的問題，對於一個規模是n的輸入，在n^k的時間內得到結果，稱為P問題。有些問題要復雜些，沒有多項式時間的解，但是可以在多項式時間里驗證某個猜測是不是正確。比如問4294967297是不是質數？如果要直接入手的話，那麼要把小於4294967297的平方根的所有素數都拿出來，看看能不能整除。還好歐拉告訴我們，這個數等於641和6700417的乘積，不是素數，很好驗證的，順便麻煩轉告費馬他的猜想不成立。大數分解、Hamilton迴路之類的問題，都是可以多項式時間內驗證一個「解」是否正確，這類問題叫做NP問題。

（4）在計算演算法時間復雜度時有以下幾個簡單的程序分析法則:

(1).對於一些簡單的輸入輸出語句或賦值語句,近似認為需要O(1)時間

(2).對於順序結構,需要依次執行一系列語句所用的時間可採用大O下"求和法則"

求和法則:是指若演算法的2個部分時間復雜度分別為 T1(n)=O(f(n))和 T2(n)=O(g(n)),則 T1(n)+T2(n)=O(max(f(n), g(n)))

特別地,若T1(m)=O(f(m)), T2(n)=O(g(n)),則 T1(m)+T2(n)=O(f(m) + g(n))

(3).對於選擇結構,如if語句,它的主要時間耗費是在執行then字句或else字句所用的時間,需注意的是檢驗條件也需要O(1)時間

(4).對於循環結構,循環語句的運行時間主要體現在多次迭代中執行循環體以及檢驗循環條件的時間耗費,一般可用大O下"乘法法則"

乘法法則: 是指若演算法的2個部分時間復雜度分別為 T1(n)=O(f(n))和 T2(n)=O(g(n)),則 T1*T2=O(f(n)*g(n))

(5).對於復雜的演算法,可以將它分成幾個容易估算的部分,然後利用求和法則和乘法法則技術整個演算法的時間復雜度

另外還有以下2個運演算法則:(1) 若g(n)=O(f(n)),則O(f(n))+ O(g(n))= O(f(n))；(2) O(Cf(n)) = O(f(n)),其中C是一個正常數

（5）下面分別對幾個常見的時間復雜度進行示例說明：

(1)、O(1)

Temp=i; i=j; j=temp;

以上三條單個語句的頻度均為1，該程序段的執行時間是一個與問題規模n無關的常數。演算法的時間復雜度為常數階，記作T(n)=O(1)。注意：如果演算法的執行時間不隨著問題規模n的增加而增長，即使演算法中有上千條語句，其執行時間也不過是一個較大的常數。此類演算法的時間復雜度是O(1)。
(2)、O(n2)

2.1. 交換i和j的內容

sum=0； （一次）
for(i=1;i<=n;i++) （n+1次）
for(j=1;j<=n;j++) （n2次）
sum++； （n2次）
解：因為Θ(2n2+n+1)=n2（Θ即：去低階項，去掉常數項，去掉高階項的常參得到），所以T(n)= =O(n2)；

2.2.

for (i=1;i<n;i++)
{
y=y+1; ①
for (j=0;j<=(2*n);j++)
x++; ②
}
解： 語句1的頻度是n-1
語句2的頻度是(n-1)*(2n+1)=2n2-n-1
f(n)=2n2-n-1+(n-1)=2n2-2；

又Θ(2n2-2)=n2
該程序的時間復雜度T(n)=O(n2).

一般情況下，對步進循環語句只需考慮循環體中語句的執行次數，忽略該語句中步長加1、終值判別、控制轉移等成分，當有若干個循環語句時，演算法的時間復雜度是由嵌套層數最多的循環語句中最內層語句的頻度f(n)決定的。

(3)、O(n)

a=0;
b=1; ①
for (i=1;i<=n;i++) ②
{
s=a+b;③
b=a;④
a=s;⑤
}
解： 語句1的頻度：2,
語句2的頻度： n,
語句3的頻度： n-1,
語句4的頻度：n-1,
語句5的頻度：n-1,
T(n)=2+n+3(n-1)=4n-1=O(n).
(4)、O(log2n)

i=1; ①
while (i<=n)
i=i*2; ②
解： 語句1的頻度是1,
設語句2的頻度是f(n), 則：2^f(n)<=n;f(n)<=log2n
取最大值f(n)=log2n,
T(n)=O(log2n )

(5)、O(n3)

for(i=0;i<n;i++)
{
for(j=0;j<i;j++)
{
for(k=0;k<j;k++)
x=x+2;
}
}
解：當i=m, j=k的時候,內層循環的次數為k當i=m時, j 可以取 0,1,...,m-1 , 所以這里最內循環共進行了0+1+...+m-1=(m-1)m/2次所以,i從0取到n, 則循環共進行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6所以時間復雜度為O(n3).

（5）常用的演算法的時間復雜度和空間復雜度

一個經驗規則：其中c是一個常量，如果一個演算法的復雜度為c 、 log2n 、n 、 n*log2n ,那麼這個演算法時間效率比較高 ，如果是2n ,3n ,n!，那麼稍微大一些的n就會令這個演算法不能動了，居於中間的幾個則差強人意。

演算法時間復雜度分析是一個很重要的問題，任何一個程序員都應該熟練掌握其概念和基本方法，而且要善於從數學層面上探尋其本質，才能准確理解其內涵。

2、演算法的空間復雜度

類似於時間復雜度的討論，一個演算法的空間復雜度(Space Complexity)S(n)定義為該演算法所耗費的存儲空間，它也是問題規模n的函數。漸近空間復雜度也常常簡稱為空間復雜度。
空間復雜度(Space Complexity)是對一個演算法在運行過程中臨時佔用存儲空間大小的量度。一個演算法在計算機存儲器上所佔用的存儲空間，包括存儲演算法本身所佔用的存儲空間，演算法的輸入輸出數據所佔用的存儲空間和演算法在運行過程中臨時佔用的存儲空間這三個方面。演算法的輸入輸出數據所佔用的存儲空間是由要解決的問題決定的，是通過參數表由調用函數傳遞而來的，它不隨本演算法的不同而改變。存儲演算法本身所佔用的存儲空間與演算法書寫的長短成正比，要壓縮這方面的存儲空間，就必須編寫出較短的演算法。演算法在運行過程中臨時佔用的存儲空間隨演算法的不同而異，有的演算法只需要佔用少量的臨時工作單元，而且不隨問題規模的大小而改變，我們稱這種演算法是「就地\"進行的，是節省存儲的演算法，如這一節介紹過的幾個演算法都是如此；有的演算法需要佔用的臨時工作單元數與解決問題的規模n有關，它隨著n的增大而增大，當n較大時，將佔用較多的存儲單元，例如將在第九章介紹的快速排序和歸並排序演算法就屬於這種情況。

如當一個演算法的空間復雜度為一個常量，即不隨被處理數據量n的大小而改變時，可表示為O(1)；當一個演算法的空間復雜度與以2為底的n的對數成正比時，可表示為0(10g2n)；當一個演算法的空I司復雜度與n成線性比例關系時，可表示為0(n).若形參為數組，則只需要為它分配一個存儲由實參傳送來的一個地址指針的空間，即一個機器字長空間；若形參為引用方式，則也只需要為其分配存儲一個地址的空間，用它來存儲對應實參變數的地址，

❼ 時間復雜度

演算法復雜度分為時間復雜度和空間復雜度，一個好的演算法應該具體執行時間短，所需空間少的特點。

隨著計算機硬體和軟體的提升，一個演算法的執行時間是算不太精確的。只能依據統計方法對演算法進行估算。

我們拋開硬體和軟體的因素，演算法的好壞直接影響程序的運行時間。

我們看一下小例子：

     int value = 0;                         // 執行了1次

     for (int i = 0; i < n; i++) {       // 執行了n次

          value += i;

     }

     這個演算法執行了 1 + n 次，如果n無限大，我們可以把前邊的1忽略，也就是說這個演算法執行了n次

     時間復雜度常用大O符號表示，這個演算法的時間復雜度就是O(n).

     概念： 一般情況下，演算法的基本操作重復執行的次數是模塊n的某一函數f(n),因此，演算法的時間復雜度記做 T(n) = O(f(n))。 隨著模塊n的增大，演算法執行的時間增長率f(n)的增長率成正比，所以f(n)越小，演算法 的時間復雜度越低，演算法的效率越高。

計算時間復雜度

     1.去掉運行時間中的所有加法常數。

     2.只保留最高階項。

     3.如果最高階項存在且不是1，去掉與這個最高階相乘的常數得到時間復雜度

我們看一個例子

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

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

               // do .....

          }

     }

當 i = 0 時 裡面的fo循環執行了n次，當i等待1時裡面的for循環執行了n -  1次，當i 等於2里裡面的fro執行了n - 2次........所以執行的次數是

根據我們上邊的時間復雜度演算法

1.去掉運行時間中的所有加法常數： 沒有加法常數不用考慮

2.只保留最高階項:只保留

3. 去掉與這個最高階相乘的常數:  去掉

只剩下

最終這個演算法的時間復雜度為

再看一個線性的

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

          // do .....

     }

     因為循環要執行n次所以時間復雜度為O(n)

其它的我也就不一個一個算了，下面給出了常用的時間復雜度

❽ 各種演算法的時間復雜度

O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)

一般時間復雜度到了2 n(指數階)及更大的時間復雜度,這樣的演算法我們基本上不會用了,太不實用了.比如遞歸實現的漢諾塔問題演算法就是O(2 n).

平方階(n^2)的演算法是勉強能用,而nlogn及更小的時間復雜度演算法那就是非常高效的演算法了啊.

空間復雜度
冒泡排序,簡單選擇排序,堆排序,直接插入排序,希爾排序的空間復雜度為O(1),因為需要一個臨時變數來交換元素位置,(另外遍歷序列時自然少不了用一個變數來做索引)

快速排序空間復雜度為logn(因為遞歸調用了) ,歸並排序空間復雜是O(n),需要一個大小為n的臨時數組.

基數排序的空間復雜是O(n),桶排序的空間復雜度不確定

原文： https://blog.csdn.net/weiwenhp/article/details/8622728

❾ 演算法時間復雜度有幾種

演算法時間復雜度有3種：

1、常數階O(1),對數階O(log2n)(以2為底n的對數，下同),線性階O(n),

2、線性對數階O(nlog2n),平方階O(n^2)，立方階O(n^3),...，

3、k次方階O(n^k),指數階O(2^n)。隨著問題規模n的不斷增大，上述時間復雜度不斷增大，演算法的執行效率越低。

(9)線性選擇演算法時間復雜度擴展閱讀：

一般情況下，演算法中基本操作重復執行的次數是問題規模n的某個函數，用T(n)表示，若有某個輔助函數f(n),存在一個正常數c使得fn*c>=T(n)恆成立。記作T(n)=O(f(n)),稱O(f(n)) 為演算法的漸進時間復雜度，簡稱時間復雜度。

在各種不同演算法中，若演算法中語句執行次數為一個常數，則時間復雜度為O(1),另外，在時間頻度不相同時，時間復雜度有可能相同，如T(n)=n^2+3n+4與T(n)=4n^2+2n+1它們的頻度不同，但時間復雜度相同，都為O(n^2)。

❿ 演算法時間復雜度

O(N!)、O(2 ^N)、O(N 2)、O(NlogN)、O(N)、O(logN)、O(1)...
代表： 最壞情況的用時

一個正整數的階乘（factorial）是所有小於及等於該數的正整數的積，並且0的階乘為1。自然數n的階乘寫作n!。1808年，基斯頓·卡曼引進這個表示法。

N 的 N 次方，^ 是上標的意思

如果 aˣ = N（a>0，且a≠1），那麼數 x 叫做以 a 為底 N 的對數，記作 x=logaN，讀作以 a 為底 N 的對數，其中 a 叫做對數的底數，N 叫做真數。
其中 x 是自變數，函數的定義域是（0，+∞），即 x>0。它實際上就是指數函數的反函數，可表示為 x= aʸ 。因此指數函數里對於 a 的規定，同樣適用於對數函數。

描述演算法復雜度時,常用o(1), o(n), o(logn), o(nlogn)表示對應演算法的時間復雜度，是演算法的時空復雜度的表示。不僅僅用於表示時間復雜度，也用於表示空間復雜度。
O後面的括弧中有一個函數，指明某個演算法的耗時/耗空間與數據增長量之間的關系。其中的n代表輸入數據的量。

時間復雜度為O(n)，就代表數據量增大幾倍，耗時也增大幾倍，線性增長，比如常見的：

時間復雜度O(n^2)，就代表數據量增大n倍時，耗時增大n的平方倍，這是比線性更高的時間復雜度。比如：

O(nlogn)同理，就是n乘以logn，當數據增大256倍時，耗時增大256*8=2048倍。這個復雜度高於線性低於平方。比如：

當數據增大n倍時，耗時增大logn倍（這里的log是以2為底的，比如，當數據增大256倍時，耗時只增大8倍，是比線性還要低的時間復雜度）。比如：

O(1)就是最低的時空復雜度了，也就是耗時/耗空間與輸入數據大小無關，無論輸入數據增大多少倍，耗時/耗空間都不變。 比如：

代入 N 以後的數值，和耗時的關系， 10 ^ 8 => 秒級 ，最大的 N 分別是：