查找的方法：

排序的方法：

簡單的數據結構：

一、算計基礎

1.1、什麽是算法：

算法（Algorithm）是指解題方案的準確而完整的描述，是一系列解決問題的清晰指令，算法代表著用系統的方法描述解決問題的策略機制。也就是說，能夠對一定規範的輸入，在有限時間內獲得所要求的輸出。如果一個算法有缺陷，或不適合於某個問題，執行這個算法將不會解決這個問題。不同的算法可能用不同的時間、空間或效率來完成同樣的任務。一個算法的優劣可以用空間復雜度與時間復雜度來衡量。

簡單的說，算法就是一個計算的過程，解決問題的辦法。

一個算法應該具有以下七個重要的特征：

①有窮性（Finiteness）：算法的有窮性是指算法必須能在執行有限個步驟之後終止；

②確切性(Definiteness)：算法的每一步驟必須有確切的定義；

③輸入項(Input)：一個算法有0個或多個輸入，以刻畫運算對象的初始情況，所謂0個輸入是指算法本身定出了初始條件；

④輸出項(Output)：一個算法有一個或多個輸出，以反映對輸入數據加工後的結果。沒有輸出的算法是毫無意義的；

⑤可行性(Effectiveness)：算法中執行的任何計算步驟都是可以被分解為基本的可執行的操作步，即每個計算步都可以在有限時間內完成（也稱之為有效性）；

⑥高效性(High efficiency)：執行速度快，占用資源少；

⑦健壯性(Robustness)：對數據響應正確。

1.2、時間復雜度

定義：如果一個問題的規模是n，解這一問題的某一算法所需要的時間為T(n)，它是n的某一函數 T(n)稱為這一算法的“時間復雜性”。

當輸入量n逐漸加大時，時間復雜性的極限情形稱為算法的“漸近時間復雜性”。

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

計算機科學中，算法的時間復雜度是一個函數，它定量描述了該算法的運行時間,時間復雜度常用大O符號（大O符號（Big O notation）是用於描述函數漸進行為的數學符號。更確切地說，它是用另一個（通常更簡單的）函數來描述一個函數數量級的漸近上界。在數學中，它一般用來刻畫被截斷的無窮級數尤其是漸近級數的剩余項；在計算機科學中，它在分析算法復雜性的方面非常有用。）表述，使用這種方式時，時間復雜度可被稱為是漸近的，它考察當輸入值大小趨近無窮時的情況。

大O，簡而言之可以認為它的含義是“order of”（大約是）。

無窮大漸近
大O符號在分析算法效率的時候非常有用。舉個例子，解決一個規模為 n 的問題所花費的時間（或者所需步驟的數目）可以被求得：T(n) = 4n^2 - 2n + 2。
當 n 增大時，n^2; 項將開始占主導地位，而其他各項可以被忽略——舉例說明：當 n = 500，4n^2; 項是 2n 項的1000倍大，因此在大多數場合下，省略後者對表達式的值的影響將是可以忽略不計的。

時間復雜度的計算：

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

一個算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。

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

在計算時間復雜度的時候，先找出算法的基本操作，然後根據相應的各語句確定它的執行次數，再找出T（n）的同數量級（它的同數量級有以下：1，Log₂n ，n ，nLog₂n ，n的平方，n的三次方，2的n次方，n！），找出後，f（n）=該數量級，若T(n)/f(n)求極限可得到一常數c，則時間復雜度T（n）=O（f（n））。

3.常見的時間復雜度

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

常數階O(1), 對數階O(log₂n), 線性階O(n), 線性對數階O(nlog₂n), 平方階O(n²)， 立方階O(n³),...， k次方階O(n^k), 指數階O(2ⁿ) 。

其中，

1.O(n)，O(n²)， 立方階O(n³),...， k次方階O(n^k) 為多項式階時間復雜度，分別稱為一階時間復雜度，二階時間復雜度。。。。

2.O(2ⁿ)，指數階時間復雜度，該種不實用

3.對數階O(log₂n), 線性對數階O(nlog₂n)，除了常數階以外，該種效率最高

例：算法：

 1   for（i=1;i<=n;++i）
 2 
 3   {
 4 
 5      for(j=1;j<=n;++j)
 6 
 7      {
 8 
 9          c[ i ][ j ]=0; //該步驟屬於基本操作 執行次數：n^2
10 
11           for(k=1;k<=n;++k)
12 
13                c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //該步驟屬於基本操作 執行次數：n^3
14 
15      }
16 
17   }

則有 T（n）= n^2+n^3，根據上面括號裏的同數量級，我們可以確定 n^3為T（n）的同數量級

則有f（n）= n^3，然後根據T（n）/f（n）求極限可得到常數c

則該算法的 時間復雜度：T（n）=O（n^3)

時間復雜度為：O(1)

1 Temp=i;
2 i=j;
3 j=temp;                 

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

時間復雜度為：O(n²)

交換i和j的內容

1      sum=0；                 （一次）
2      for(i=1;i<=n;i++)       （n次 ）
3         for(j=1;j<=n;j++) （n^2次 ）
4          sum++；       （n^2次 ）

解：T(n)=2n^2+n+1 =O(n^2)

例子

1   for (i=1;i<n;i++)
2     {
3         y=y+1;         ①  
4         for (j=0;j<=(2*n);j++)   
5            x++;        ②     
6     }        

解： 語句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)

1     a=0;
2     b=1;                      ①
3     for (i=1;i<=n;i++) ②
4     { 
5        s=a+b;　　　　③
6        b=a;　　　　　④ 
7        a=s;　　　　　⑤
8     }

解：語句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(log₂n )

1      i=1;       ①
2     while (i<=n)
3        i=i*2; ②

解： 語句1的頻度是1,

設語句2的頻度是f(n), 則：2^f(n)<=n;f(n)<=log2n

取最大值f(n)= log2n,

T(n)=O(log2n )

時間復雜度為：O(n³)

1   for(i=0;i<n;i++)
2     { 
3        for(j=0;j<i;j++) 
4        {
5           for(k=0;k<j;k++)
6              x=x+2; 
7        }
8     }

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

時間復雜度小結：

間復雜度是用來估計算法運行時間的一個式子（單位）。

一般來說，時間復雜度高的算法比復雜度低的算法快。

常見的時間復雜度（按效率排序）

O(1)<O(log₂n)<O(n)<O(nlog₂n)<O(n²)<O(n²log₂n)<O(n³)

不常見的時間復雜度（看看就好）

O(n!) O(2ⁿ) O(nⁿ) …

如何一眼判斷時間復雜度？

循環減半的過程?O(logn)

幾次循環就是n的幾次方的復雜度

3、空間復雜度

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

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

分析一個算法所占用的存儲空間要從各方面綜合考慮。如對於遞歸算法來說，一般都比較簡短，算法本身所占用的存儲空間較少，但運行時需要一個附加堆棧，從而占用較多的臨時工作單元；若寫成非遞歸算法，一般可能比較長，算法本身占用的存儲空間較多，但運行時將可能需要較少的存儲單元。

一個算法的空間復雜度只考慮在運行過程中為局部變量分配的存儲空間的大小，它包括為參數表中形參變量分配的存儲空間和為在函數體中定義的局部變量分配的存儲空間兩個部分。若一個算法為 遞歸算法，其空間復雜度為遞歸所使用的堆棧空間的大小，它等於一次調用所分配的臨時存儲空間的大小乘以被調用的次數(即為遞歸調用的次數加1，這個1表示開始進行的一次非遞歸調用)。算法的空間復雜度一般也以數量級的形式給出。如當一個算法的空間復雜度為一個常量，即不隨被處理數據量n的大小而改變時，可表示為O(1)；當一個算法的空間復雜度與以2為底的n的對數成正比時，可表示為O(log2n)；當一個算法的空間復雜度與n成線性比例關系時，可表示為O(n).若形參為數組，則只需要為它分配一個存儲由實參傳送來的一個地址指針的空間，即一個機器字長空間；若形參為引用方式，則也只需要為其分配存儲一個地址的空間，用它來存儲對應實參變量的地址，以便由系統自動引用實參變量。

時間復雜度與空間復雜度比較:

對於一個算法，其時間復雜度和空間復雜度往往是相互影響的。當追求一個較好的時間復雜度時，可能會使空間復雜度的性能變差，即可能導致占用較多的存儲空間；反之，當追求一個較好的空間復雜度時，可能會使時間復雜度的性能變差，即可能導致占用較長的運行時間。另外，算法的所有性能之間都存在著或多或少的相互影響。因此，當設計一個算法(特別是大型算法)時，要綜合考慮算法的各項性能，算法的使用頻率，算法處理的數據量的大小，算法描述語言的特性，算法運行的機器系統環境等各方面因素，才能夠設計出比較好的算法。算法的時間復雜度和空間復雜度合稱為算法的復雜度。

二、查找

列表查找：從列表中查找指定元素

輸入：列表、待查找元素

輸出：元素下標或未查找到元素

常見的查找方法有兩種：

2.1順序查找

從列表第一個元素開始，順序進行搜索，直到找到為止。

查找成功時的平均查找長度為：（假設每個數據元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;

當查找不成功時，需要n+1次比較，時間復雜度為O(n);

所以， 順序查找的時間復雜度為O(n ) 。

順序查找的實現：

2.2二分查找

從有序列表的候選區data[0:n]開始，通過對待查找的值與候選區中間值的比較，可以使候選區減少一半。

說明：元素必須是有序的，如果是無序的則要先進行排序操作。

基本思想：也稱為是折半查找，屬於有序查找算法。用給定值k先與中間結點的關鍵字比較，中間結點把線形表分成兩個子表，若相等則查找成功；若不相等，再根據k與該中間結點關鍵字的比較結果確定下一步查找哪個子表，這樣遞歸進行，直到查找到或查找結束發現表中沒有這樣的結點。

復雜度分析： 最壞情況下，關鍵詞比較次數為log₂(n+1)，且 期望時間復雜度為O(log₂n) ；

註： 折半查找的前提條件是需要有序表順序存儲，對於靜態查找表，一次排序後不再變化，折半查找能得到不錯的效率。但對於需要 頻繁執行插入或刪除操作的數據集來說，維護有序的排序會帶來不小的工作量，那就不建議使用。

python學習-09（查找、排序和淺談數據結構）