為什麼計算時間感覺很復雜

1. 古代以干支紀年記月記日記時，雖說邏輯通順卻非常復雜，循環周期又長，為什麼用這么復雜的方法來記錄時間

古人以「混元未分」作為「先天」，這個「先天」不可計算，但以「渾元」為雜處而齊同，便可以成為「古始」象徵，道德經說「能知古始，是謂道紀，執古之道，以御今之有」，就是指的古代天官積算上元甲子的基本思想，古代天官以日月五星齊聚於冬至子時九大因素另外加上60甲子作為尺度得到一個會合周期點。作為甲子年月日時，也是作為天地開辟的象徵，請注意這里說的是「象徵」。因為這種會合點在歷史上的天官計算中有很多個，並且都可推算出現今的干支記時。而且這種天地開辟是「渾元」而不是「混元」，所以不能認為「渾元」就是宇宙大爆炸。而是「齊同之術」，由此而出的「同餘式」機械演算法一直領先世界。
如果將這種積年法加上農歷就可以定位太陽過宮以及月象的位置。而干支記法都可以貫穿其中。這本身也反映了中國特有的歷史觀。從那一時期開始，中國就不再用史詩的方式來記錄歷史，時間感非常清晰。

2. 時間復雜度(計算方法,如果計算,及其解釋)

時間復雜度
1.
演算法復雜度分為
時間復雜度和空間復雜度。
作用:
時間復雜度是度量演算法執行的時間長短;而空間復雜度是度量演算法所需存儲空間的大小。
2.
一般情況下，演算法的基本操作重復執行的次數是模塊n的某一個函數f(n)，因此，演算法的時間復雜度記做:T(n)=O(f(n))
分析:隨著模塊n的增大，演算法執行的時間的增長率和f(n)的增長率成正比，所以f(n)越小，演算法的時間復雜度越低，演算法的效率越高。
3.
在計算時間復雜度的時候，先找出演算法的基本操作，然後根據相應的各語句確定它的執行次數，在找出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. 關於演算法時間復雜度分析的疑問

誰跟你說的分析時間復雜度是用比較次數來衡量的？
一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
一般情況下，演算法的基本操作重復執行的次數是模塊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))

一般情況時間復雜度是以你演算法中最復雜的那個循環來看的，
比如有個
for(i = 0;i < n;i ++)
{
for(j = 0;j < n;j ++)
{
...

}
}
後面不管他有多少個單獨的
for(i = 0;i < n;i ++)
{
...

}
他的時間復雜度都是O(n2)
不會是O(n2) + O(n) + O(n) + O(2n)...這樣的

4. 1.為什麼要分析最壞情況下的演算法時間復雜性

哈哈，這個問題問得好！我記得我也問過老師這個問題，結果老師的答案是程序就是要看最差的時間，而且最差時間比較容易計算出來。比如說遍歷一個二叉樹，計算平均時間相當復雜，是2（1+1/n）ln n ，約等於1.38log n。需要一個求和，公式相當復雜（詳見《數據結構：思想與實現》高教版204頁）

所以，只用最壞了。好計算

5. 究竟什麼是時間復雜度，怎麼求時間復雜度，看這一篇就夠了

時間復雜度就是用來方便開發者估算出程序的運行時間

我們該如何估計程序運行時間呢，我們通常會估計演算法的操作單元數量，來代表程序消耗的時間， 這里我們默認CPU的每個單元運行消耗的時間都是相同的。

假設演算法的問題規模為n，那麼操作單元數量便用函數f(n)來表示

隨著數據規模n的增大，演算法執行時間的增長率和f(n)的增長率相同，這稱作為演算法的漸近時間復雜度，簡稱時間復雜度，記為 O(f(n))

這里就要說一下這個大O，什麼是大O呢，很多同學說時間復雜度的時候都知道O(n)，O(n^2)，但說不清什麼是大O

演算法導論給出的解釋： 大O用來表示上界的 ，當用它作為演算法的最壞情況運行時間的上界，就是對任意數據輸入的運行時間的上界。

同樣演算法導論給出了例子：拿插入排序來說，插入排序的時間復雜度我們都說是O(n^2)

但是在數據本來有序的情況下時間復雜度是O(n)，也就對於所有輸入情況來說，最壞是O(n^2) 的時間復雜度，所以稱插入排序的時間復雜度為O(n^2)

同樣的同理我們在看一下快速排序，都知道快速排序是O(nlogn)，但是當數據已經有序情況下，快速排序的時間復雜度是O(n^2) 的，嚴格從大O的定義來講，快速排序的時間復雜度應該是O(n^2)

但是我們依然說快速排序是O(nlogn)的時間復雜度，這個就是業內的一個默認規定，我們這里說的O 代表的就是一般情況，不是嚴格的上界

所以這里大家知道這么一回事就好了

面試中面試官絕對不會針對快速排序的時間復雜度問題來討論O的定義， 大家知道討論的時間復雜度就是指一般情況下的時間復雜度就好了。

大家要對演算法的時間復雜度有這樣的一個概念

就是同一個演算法的時間復雜度不是一成不變的，和輸入的數據形式依然有關系

我們主要關心的還是一般情況下的數據形式 。

面試中說道演算法的時間復雜度是多少指的都是一般情況

但是如果面試官和我們深入探討一個演算法的實現以及性能的時候 我們就要時刻想著 數據用例的不一樣 時間復雜度也是不同的，這一點同學們要注意

這個圖中我們可以看出 不同演算法的時間復雜度 在不同數據輸入規模下的差異 。

我們在決定使用那些演算法的時候 ，不是時間復雜越低的越好，要考慮數據規模，如果數據規模很小 甚至可以用O(n^2)的演算法比 O(n)的更合適

就像上圖中圖中 O(5n^2) 和 O(100n) 在n為20之前 很明顯 O(5n^2)是更優的，所花費的時間也是最少的。

那我們為什麼在計算時間復雜度的時候要忽略常數項系數呢，也就說O(100n) 就是O(n)的時間復雜度，O(5n^2) 就是O(n^2)的時間復雜度

而且要默認O(n) 優於O(n^2) 呢 ？

這里就又涉及到大O的定義

因為 大O其實就是數據量級突破一個點且數據量級非常大的情況下所表現出的時間復雜度 ，這個點也就是 常數項系數已經不起決定性作用的點。

例如上圖中 20 就是那個點 ，n只要大於20 常數項系數已經不起決定性作用了。

所以我們說的時間復雜度都是省略常數項系數的，是因為一般情況下我們都是默認數據規模足夠的大，基於這樣的事實 我們給出的演算法時間復雜的的一個排行如下所示：

O(1)常數階 < O(logn)對數階 < O(n)線性階 < O(n^2)平方階 < O(n^3)(立方階) < O(2^n) (指數階)

我們平時說這個 演算法的時間復雜度是logn的，一定是log 以2為底n的對數么？

其實不然，也可以是以10為底n的對數，也可以是以20為底n的對數，但我們統一說 logn，也就是忽略底數的描述。

為什麼可以這么做呢？

如下圖所示

假如我們有兩個演算法的時間復雜度 分別是log以2為底n的對數 和 log 以10為底n的對數

那麼這里如果大家還記得我們高中數學的話， 應該不能理解 以2為底n的對數 = 以2為底10的對數 乘以 以10為底n的對數

那這里以2為底10的對數 是一個常數，而我在上面已經講述了我們計算時間復雜度是忽略常數項系數的

抽象一下 log 以i為底n的對數 等於 log 以j為底n的對數，所以我們忽略了i，直接說是logn，正式因為logij 是就一個常數

所以，這樣就應該不難理解了 我們為什麼忽略底數了

有時候，我們去計算時間復雜度的時候 發現不是一個 簡單的O(n) 或者O(n^2)， 而是一個復雜的表達式，例如：

O(2*n^2 + 10*n + 1000)

那這里我們通常如何描述這個演算法的時間復雜度呢，一種方法就是簡化法

去掉運行時間中的加法常數項 （因為常數項並不會因為n的增大而增加計算機的操作次數）

O(2*n^2 + 10*n)

去掉常數系數 （我們剛剛已經詳細講過為什麼可以去掉常數項的原因了）

O(n^2 + n)

只保留保留最高項 去掉數量級小一級的n （因為n^2 的數據規模遠大於 n），最終簡化為：

O(n^2)

如果這一步同學們理解有困難，那也可以做提取n的操作，變成 O(n(n+1)) ，省略加法常數項後 也別變成了

O(n^2)

所以最後我們說：我們這個演算法的演算法時間復雜度是 O(n^2)

也可以用另一種簡化的思路，當n大於40的時候 ， 這個復雜度 會一直小於 O(3*n^2)

O(2*n^2 + 10*n + 1000) < O(3*n^2)

所以說 最後我們省略掉常數項系數最終時間復雜度也是 O(n^2)

我們通過一道題目，來看一下具體時間復雜度應該怎麼算

題目描述：找出n個字元串中相同的兩個字元串（假設這里只有兩個相同的字元串）

一些同學可能以為解決這道題目可以採用枚舉遍歷的解法，時間復雜度是 O(n^2)

這個時間復雜度其實是不對的。

這里 一些同學忽略了字元串比較的時間消耗，這里並不像int 型數字做比較那麼簡單

除了n^2 次的遍歷次數外， 字元串比較依然要消耗m次操作（m也就是字母串的長度），所以時間復雜度是 O(m*n*n)

那麼我們再想一下其他解題思路

我們先排對n個字元串按字典序來排序，排序後n個字元串就是有序的，意味著兩個相同的字元串就是挨在一起

然後在遍歷一遍n個字元串，這樣就找到兩個相同的字元串了

那我們來看看這種演算法的時間復雜度

快速排序時間復雜度 為O(nlogn)，依然要考慮字元串的長度是m，那麼快速排序每次的比較都要有m次的字元比較的操作，就是 O(m*n*logn)

之後我們還要遍歷一遍這n個字元串找出兩個相同的字元串，別忘了遍歷的時候依然要比較字元串，所以總共的時間復雜度是 O(m*n*logn + n*m)

我們對 O(m*n*logn + n*m) 進行簡化操作，把 m*n 提取出來變成 O(m*n*(logn + 1)) ，

在省略常數項最後的時間復雜度是 O(m*n*logn) ， 那我們比較一下時間效率 O(m*n*logn) 是不是比第一種方法 O(m*n*n) 更快一些呢

很明顯 O(m*n*logn) 要優於 O(m*n*n)

所以 先把字元串集合排序在遍歷一遍找到兩個相同字元串的方式要比直接暴力枚舉的方式更快 。

通過這個例子 希望大家對時間復雜的是怎麼算的有一個初步的理解和認識。

6. 如何計算時間復雜度

如何計算時間復雜度

定義：如果一個問題的規模是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的值非常小，因為，在 這個問題中增加一個元素就導致運行時間加倍。不幸的是，確實有許多問題 (如著名 的「巡迴售貨員問題」 )，到目前為止找到的演算法都是指數的。如果我們真的遇到這種情況， 通常應該用尋找近似最佳結果的演算法替代之。

7. 關於計算演算法的時間復雜度問題

因為每次i是乘2而不是加1。所以其實只需要乘(log(2, n)上取整次)就可以超過n了。

8. 演算法的時間復雜度怎麼求啊，感覺很難。

如果只是用O來估算的話其實不難吧，比如O(n)。
但是要用表達式來准確的表達演算法復雜度就比較困難了，就必須要精確計算基本指令和輸入數據規模的關系了。

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

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

1.語句頻度在演算法中一個語句的執行次數稱為語句頻度或時間頻度，記為T（n）。

2）演算法的漸進時間復雜度一般情況下，演算法的執行時間T是問題規模n的函數，記作T（n）。要精確地表示演算法的運行時間函數常常是很困難的，即使能夠給出，也可能是個相當復雜的函數，函數的求解本身也是相當復雜的。為了客觀地反映一個演算法的執行時間，可以用演算法中基本語句的執行次數的數量級來度量演算法的工作量，稱作演算法的漸進時間復雜度，簡稱時間復雜度，通常用O來表示。

10. 時間復雜度計算技巧

一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
演算法復雜度
演算法復雜度分為時間復雜度和空間復雜度。其作用： 時間復雜度是指執行演算法所需要的計算工作量；而空間復雜度是指執行這個演算法所需要的內存空間。（演算法的復雜性體運行該演算法時的計算機所需資源的多少上，計算機資源最重要的是時間和空間（即寄存器）資源，因此復雜度分為時間和空間復雜度。）