當前位置:首頁 » 操作系統 » 演算法的時間階

演算法的時間階

發布時間: 2022-07-03 18:51:41

『壹』 演算法時間復雜度有幾種

演算法時間復雜度有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的不斷增大,上述時間復雜度不斷增大,演算法的執行效率越低。

(1)演算法的時間階擴展閱讀:

一般情況下,演算法中基本操作重復執行的次數是問題規模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)。

『貳』 如何衡量一個時間演算法的時間效率

一個演算法執行所耗費的時間,從理論上是不能算出來的,必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試,只需知道哪個演算法花費的時間多,哪個演算法花費的時間少就可以了。

並且一個演算法花費的時間與演算法中語句的執行次數成正比例,哪個演算法中語句執行次數多,它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。演算法的時間復雜度是指執行演算法所需要的計算工作量。

時間效率,一定生產時間內,機器實際運轉時間與理論運轉時間之比,通常用百分率表示。與設備自動化程度、速度、卷裝尺寸、工人操作熟練程度及看台數有關。

(2)演算法的時間階擴展閱讀:

點在空間中變化對點的描述稱為被描述點相當於該點的時間【該點運動到某一位置時,被描述點都會有唯一的對應位置,稱為此時被描述點的位置】。被描述點可以隨時間變化位置不變,可知時間與被描述點的位置有函數關系。

空間使事物具有了變化性,即因為空間的存在,所以事物才可以發生變化。空間是沒有能量的事物,即當事物能產生變化時,變化產生的能量已經和阻礙的能量相互抵消。

天文測時所依賴的是地球自轉,而地球自轉的不均勻性使得天文方法所得到的時間(世界時)精度只能達到10-9,無法滿足二十世紀中葉社會經濟各方面的需求。一種更為精確和穩定的時間標准應運而生,這就是「原子鍾」。

世界各國都採用原子鍾來產生和保持標准時間,這就是「時間基準」,然後,通過各種手段和媒介將時間信號送達用戶,這些手段包括:短波、長波、電話網、互聯網、衛星等。這一整個工序,就稱為「授時系統」。

『叄』 演算法的空間復雜度和時間復雜度的關系

論壇

活動

招聘

專題

打開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).若形參為數組,則只需要為它分配一個存儲由實參傳送來的一個地址指針的空間,即一個機器字長空間;若形參為引用方式,則也只需要為其分配存儲一個地址的空間,用它來存儲對應實參變數的地址,

『肆』 為什麼說演算法時間復雜度是為對數階、冪函數階時,演算法的運行時間是可以接受的,稱這些演算法

因為隨著數據量的增加,對數階,冪函數階的演算法時間開銷增加速度逐漸減小,而指數階階乘階消耗時間增加速度太快,但數據量達到一定程度的時候,前者消耗的時間依然在可接受范圍內,而後者將超出可接受時間。
比如 log n 和n^3 當n=10^9時 一般的電腦按照每秒計算10^9次 。那麼n^3的演算法已經要消耗數萬年的時間才能解決,而log n的演算法只需要不到1s就能夠出演算法

『伍』 JAVA中演算法的時間復雜程度是什麼

JAVA中演算法的時間復雜程度 簡而言之就是運算時候的執行次數的統計
1.時間頻度
一個演算法執行所耗費的時間,從理論上是不能算出來的,必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試,只需知道哪個演算法花費的時間多,哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例,哪個演算法中語句執行次數多,它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
2.計算方法
1. 一般情況下,演算法的基本操作重復執行的次數是模塊n的某一個函數f(n),因此,演算法的時間復雜度記做:T(n)=O(f(n)) 分析:隨著模塊n的增大,演算法執行的時間的增長率和f(n)的增長率成正比,所以f(n)越小,演算法的時間復雜度越低,演算法的效率越高。 2. 在計算時間復雜度的時候,先找出演算法的基本操作,然後根據相應的各語句確定它的執行次數,再找出T(n)的同數量級(它的同數量級有以下:1,Log2n ,n ,nLog2n ,n的平方,n的三次方,2的n次方,n!),找出後,f(n)=該數量級,若T(n)/f(n)求極限可得到一常數c,則時間復雜度T(n)=O(f(n))
例:演算法:
for(i=1;i<=n;++i)
{
for(j=1;j<=n;++j)
{
c[ i ][ j ]=0; //該步驟屬於基本操作 執行次數:n的平方 次
for(k=1;k<=n;++k)
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //該步驟屬於基本操作 執行次數:n的三次方 次
}
} 則有 T(n)= n的平方+n的三次方,根據上面括弧里的同數量級,我們可以確定 n的三次方 為T(n)的同數量級
則有f(n)= n的三次方,然後根據T(n)/f(n)求極限可得到常數c
則該演算法的 時間復雜度:T(n)=O(n的三次方)
3.分類
按數量級遞增排列,常見的時間復雜度有: 常數階O(1),對數階O(log2n),線性階O(n), 線性對數階O(nlog2n),平方階O(n2),立方階O(n3),..., k次方階O(nk), 指數階O(2n) 。隨著問題規模n的不斷增大,上述時間復雜度不斷增大,演算法的執行效率越低。

『陸』 演算法時間復雜度怎麼算

一、概念
時間復雜度是總運算次數表達式中受n的變化影響最大的那一項(不含系數)
比如:一般總運算次數表達式類似於這樣:
a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f
a ! =0時,時間復雜度就是O(2^n);
a=0,b<>0 =>O(n^3);
a,b=0,c<>0 =>O(n^2)依此類推
eg:
(1) for(i=1;i<=n;i++) //循環了n*n次,當然是O(n^2)
for(j=1;j<=n;j++)
s++;
(2) for(i=1;i<=n;i++)//循環了(n+n-1+n-2+...+1)≈(n^2)/2,因為時間復雜度是不考慮系數的,所以也是O(n^2)
for(j=i;j<=n;j++)
s++;
(3) for(i=1;i<=n;i++)//循環了(1+2+3+...+n)≈(n^2)/2,當然也是O(n^2)
for(j=1;j<=i;j++)
s++;
(4) i=1;k=0;
while(i<=n-1){
k+=10*i; i++; }//循環了n-1≈n次,所以是O(n)(5) for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
for(k=1;k<=j;k++)
x=x+1;
//循環了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6(這個公式要記住哦)≈(n^3)/3,不考慮系數,自然是O(n^3)
另外,在時間復雜度中,log(2,n)(以2為底)與lg(n)(以10為底)是等價的,因為對數換底公式:
log(a,b)=log(c,b)/log(c,a)
所以,log(2,n)=log(2,10)*lg(n),忽略掉系數,二者當然是等價的
二、計算方法1.一個演算法執行所耗費的時間,從理論上是不能算出來的,必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試,只需知道哪個演算法花費的時間多,哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例,哪個演算法中語句執行次數多,它花費時間就多。
一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
2.一般情況下,演算法的基本操作重復執行的次數是模塊n的某一個函數f(n),因此,演算法的時間復雜度記做:T(n)=O(f(n))。隨著模塊n的增大,演算法執行的時間的增長率和f(n)的增長率成正比,所以f(n)越小,演算法的時間復雜度越低,演算法的效率越高。
在計算時間復雜度的時候,先找出演算法的基本操作,然後根據相應的各語句確定它的執行次數,再找出T(n)的同數量級(它的同數量級有以下:1,Log2n ,n ,nLog2n ,n的平方,n的三次方,2的n次方,n!),找出後,f(n)=該數量級,若T(n)/f(n)求極限可得到一常數c,則時間復雜度T(n)=O(f(n))。
3.常見的時間復雜度
按數量級遞增排列,常見的時間復雜度有:
常數階O(1), 對數階O(log2n), 線性階O(n), 線性對數階O(nlog2n), 平方階O(n^2), 立方階O(n^3),..., k次方階O(n^k), 指數階O(2^n) 。
其中,1.O(n),O(n^2), 立方階O(n^3),..., k次方階O(n^k) 為多項式階時間復雜度,分別稱為一階時間復雜度,二階時間復雜度。。。。2.O(2^n),指數階時間復雜度,該種不實用3.對數階O(log2n), 線性對數階O(nlog2n),除了常數階以外,該種效率最高
例:演算法:
for(i=1;i<=n;++i)
{
for(j=1;j<=n;++j)
{
c[ i ][ j ]=0; //該步驟屬於基本操作 執行次數:n^2
for(k=1;k<=n;++k)
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //該步驟屬於基本操作 執行次數:n^3
}
}
則有 T(n)= n^2+n^3,根據上面括弧里的同數量級,我們可以確定 n^3為T(n)的同數量級
則有f(n)= n^3,然後根據T(n)/f(n)求極限可得到常數c
則該演算法的 時間復雜度:T(n)=O(n^3)
四、

定義:如果一個問題的規模是n,解這一問題的某一演算法所需要的時間為T(n),它是n的某一函數
T(n)稱為這一演算法的「時間復雜性」。

當輸入量n逐漸加大時,時間復雜性的極限情形稱為演算法的「漸近時間復雜性」。

我們常用大O表示法表示時間復雜性,注意它是某一個演算法的時間復雜性。大O表示只是說有上界,由定義如果f(n)=O(n),那顯然成立f(n)=O(n^2),它給你一個上界,但並不是上確界,但人們在表示的時候一般都習慣表示前者。

此外,一個問題本身也有它的復雜性,如果某個演算法的復雜性到達了這個問題復雜性的下界,那就稱這樣的演算法是最佳演算法。

「大O記法」:在這種描述中使用的基本參數是
n,即問題實例的規模,把復雜性或運行時間表達為n的函數。這里的「O」表示量級 (order),比如說「二分檢索是 O(logn)的」,也就是說它需要「通過logn量級的步驟去檢索一個規模為n的數組」記法 O ( f(n) )表示當 n增大時,運行時間至多將以正比於 f(n)的速度增長。

這種漸進估計對演算法的理論分析和大致比較是非常有價值的,但在實踐中細節也可能造成差異。例如,一個低附加代價的O(n2)演算法在n較小的情況下可能比一個高附加代價的 O(nlogn)演算法運行得更快。當然,隨著n足夠大以後,具有較慢上升函數的演算法必然工作得更快。

O(1)

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

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

O(n^2)

2.1.
交換i和j的內容
sum=0;(一次)
for(i=1;i<=n;i++)(n次 )
for(j=1;j<=n;j++)
(n^2次 )
sum++;(n^2次 )
解:T(n)=2n^2+n+1 =O(n^2)

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)=2n^2-n-1
f(n)=2n^2-n-1+(n-1)=2n^2-2
該程序的時間復雜度T(n)=O(n^2).

O(n)

2.3.
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).

O(log2n
)

2.4.
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 )

O(n^3)

2.5.
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(n^3).


我們還應該區分演算法的最壞情況的行為和期望行為。如快速排序的最
壞情況運行時間是 O(n^2),但期望時間是 O(nlogn)。通過每次都仔細 地選擇基準值,我們有可能把平方情況 (即O(n^2)情況)的概率減小到幾乎等於 0。在實際中,精心實現的快速排序一般都能以 (O(nlogn)時間運行。
下面是一些常用的記法:


訪問數組中的元素是常數時間操作,或說O(1)操作。一個演算法如 果能在每個步驟去掉一半數據元素,如二分檢索,通常它就取 O(logn)時間。用strcmp比較兩個具有n個字元的串需要O(n)時間。常規的矩陣乘演算法是O(n^3),因為算出每個元素都需要將n對
元素相乘並加到一起,所有元素的個數是n^2。
指數時間演算法通常來源於需要求出所有可能結果。例如,n個元 素的集合共有2n個子集,所以要求出所有子集的演算法將是O(2n)的。指數演算法一般說來是太復雜了,除非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)=4nn-2n+2 中,就有f(n)=nn,使得T(n)/f(n)的極限值為4,那麼O(f(n)),也就是時間復雜度為O(n*n)。

時間復雜度中大O階推導是:

推導大O階就是將演算法的所有步驟轉換為代數項,然後排除不會對問題的整體復雜度產生較大影響的較低階常數和系數。

有條理的說,推導大O階,按照下面的三個規則來推導,得到的結果就是大O表示法:運行時間中所有的加減法常數用常數1代替。只保留最高階項去除最高項常數。

其他常見復雜度是:

f(n)=nlogn時,時間復雜度為O(nlogn),可以稱為nlogn階。

f(n)=n³時,時間復雜度為O(n³),可以稱為立方階。

f(n)=2ⁿ時,時間復雜度為O(2ⁿ),可以稱為指數階。

f(n)=n!時,時間復雜度為O(n!),可以稱為階乘階。

f(n)=(√n時,時間復雜度為O(√n),可以稱為平方根階。

『捌』 演算法的時間復雜度是指什麼

時間復雜性,又稱時間復雜度,演算法的時間復雜度是一個函數,它定性描述該演算法的運行時間。

這是一個代表演算法輸入值的字元串的長度的函數。時間復雜度常用大O符號表述,不包括這個函數的低階項和首項系數。使用這種方式時,時間復雜度可被稱為是漸進的,亦即考察輸入值大小趨近無窮時的情況。

相關介紹:

時間復雜度是同一問題可用不同演算法解決,而一個演算法的質量優劣將影響到演算法乃至程序的效率。演算法分析的目的在於選擇合適演算法和改進演算法。

空間復雜度是對一個演算法在運行過程中臨時佔用存儲空間大小的量度,記做S(n)=O(f(n))。比如直接插入排序的時間復雜度是O(n^2),空間復雜度是O(1) 。而一般的遞歸演算法就要有O(n)的空間復雜度了,因為每次遞歸都要存儲返回信息。一個演算法的優劣主要從演算法的執行時間和所需要佔用的存儲空間兩個方面衡量。

演算法的復雜性體現在運行該演算法時的計算機所需資源的多少上,計算機資源最重要的是時間和空間(即寄存器)資源,因此復雜度分為時間和空間復雜度。

『玖』 關於演算法是時間復雜度,對數階比指數階效率高嗎

時間復雜度

(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)=n^2 3n 4與T(n)=4n^2 2n 1它們的頻度不同,但時間復雜度相同,都為O(n^2)。

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

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

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

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

演算法的時間性能分析

(1)演算法耗費的時間和語句頻度

一個演算法所耗費的時間=演算法中每條語句的執行時間之和

每條語句的執行時間=語句的執行次數(即頻度(Frequency Count))×語句執行一次所需時間

演算法轉換為程序後,每條語句執行一次所需的時間取決於機器的指令性能、速度以及編譯所產生的代碼質量等難以確定的因素。

若要獨立於機器的軟、硬體系統來分析演算法的時間耗費,則設每條語句執行一次所需的時間均是單位時間,一個演算法的時間耗費就是該演算法中所有語句的頻度之和。
求兩個n階方陣的乘積 C=A×B,其演算法如下:

# define n 100 // n 可根據需要定義,這里假定為100

void MatrixMultiply(int A[a],int B [n][n],int C[n][n])

{ //右邊列為各語句的頻度

int i ,j ,k;

(1) for(i=0; i

熱點內容
搭建阿里伺服器教程 發布:2022-08-10 22:14:20 瀏覽:361
登錄ftp的流程 發布:2022-08-10 22:11:10 瀏覽:740
手機不能緩存電視劇了 發布:2022-08-10 22:05:16 瀏覽:285
編譯webview 發布:2022-08-10 22:05:10 瀏覽:645
研究編程人 發布:2022-08-10 22:05:01 瀏覽:265
新世嘉炫音版有哪些配置 發布:2022-08-10 22:01:12 瀏覽:532
蘋果手機怎麼上傳雲端 發布:2022-08-10 22:01:01 瀏覽:417
安卓手機抖音小黃車在哪裡找到 發布:2022-08-10 22:00:55 瀏覽:863
酒店的wife密碼一般在什麼地方 發布:2022-08-10 21:58:04 瀏覽:872
c語言給十進制整數 發布:2022-08-10 21:55:57 瀏覽:76