之前一提到資料結構與演算法感覺這應該是後端要掌握的知識，對我們前端來說只要寫寫頁面，繫結事件，向後臺發發資料就好了，用不到資料結構與演算法，即使是用到演算法也有一些js的api可以實現，也許對於一些資料查詢 簡單的for迴圈就能搞定，也只是提高了幾毫秒而已完全可忽略不計，但是假如node做後臺開發的時候， 一次請求節約的幾毫秒，千萬次請求節約的就不是毫秒來計算了。看看人家那些大牛們，我這樣的小白想當老白啊，所以基本的演算法以及對資料結構的掌握這是向他們靠近必須要走的路。今天先來回顧一下大學學的基本演算法吧也是必須掌握的基本演算法。 　　還好資料結構是在畢業的時候唯一沒被賣掉的書，翻了翻書看到演算法的定義： 　　①演算法的特徵：有窮性、確定性、可行性、輸入、輸出 　　②演算法的設計衡量：正確性、可讀性、健壯性, 時間複雜度, 空間複雜度

基本演算法：

　　1.氣泡排序：

　　1.原理：比較兩個相鄰的元素，將值大的元素交換到右邊

　　2.思路：依次比較相鄰的兩個數，將比較小的數放在前面，比較大的數放在後面。

　　　　(1)第一次比較：首先比較第一和第二個數，將小數放在前面，將大數放在後面。

　　　　(2)比較第2和第3個數，將小數 放在前面，大數放在後面。

　　　　......

　　　　(3)如此繼續，直到比較到最後的兩個數，將小數放在前面，大數放在後面，重複步驟，直至全部排序完成

　　　　(4)在上面一趟比較完成後，最後一個數一定是陣列中最大的一個數，所以在比較第二趟的時候，最後一個數是不參加比較的。

　　　　(5)在第二趟比較完成後，倒數第二個數也一定是陣列中倒數第二大數，所以在第三趟的比較中，最後兩個數是不參與比較的。

　　　　(6)依次類推，每一趟比較次數減少依次

 1 function bubbleSort(arr) {
 2     var len = arr.length;
 3     for (var i = 0; i < len - 1; i++) {//外層控制迴圈多少趟，
 4         for (var j = 0; j < len - 1 - i; j++) {//內層控制每一趟的迴圈次數
 5             if (arr[j] > arr[j+1]) {        //
 
 相鄰元素兩兩對比
 6                 var temp = arr[j+1];        // 元素交換
 7                 arr[j+1] = arr[j];
 8                 arr[j] = temp;
 9             }
10         }
11     }
12     return arr;
13 }

　　2.快速排序：

　　

　　1.演算法思想
　　 快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。

　　2.實現原理

　　(1)設定兩個變數 low、high，排序開始時：low=0，high=size-1。
　　(2)整個陣列找基準正確位置，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面

　　(3)預設陣列的第一個數為基準資料，賦值給key，即key=array[low]。

　　(4)因為預設陣列的第一個數為基準，所以從後面開始向前搜尋（high–），找到第一個小於key的array[high]，就將 array[high] 賦給 array[low]，即 array[low] = array[high]。（迴圈條件是 array[high] >= key；結束時 array[high] < key）

　　(5)此時從前面開始向後搜尋（low++），找到第一個大於key的array[low]，就將 array[low] 賦給 array[high]，即 array[high] = array[low]。（迴圈條件是 array[low] <= key；結束時 array[low] > key）

　　(6)迴圈 4-5步驟，直到 low=high，該位置就是基準位置。

　　(7)把基準資料賦給當前位置。

 1 function swap(items, firstIndex, secondIndex){
 2     var temp = items[firstIndex];
 3     items[firstIndex] = items[secondIndex];
 4     items[secondIndex] = temp;
 5 }
 6 
 7 function partition(items, left, right) {
 8     var pivot = items[Math.floor((right + left) / 2)],
 9         i = left,
10         j = right;
11     while (i <= j) {
12         while (items[i] < pivot) {
13             i++;
14         }
15         while (items[j] > pivot) {
16             j--;
17         }
18         if (i <= j) {
19             swap(items, i, j);
20             i++;
21             j--;
22         }
23     }
24     return i;
25 }
26 
27 function quickSort(items, left, right) {
28     var index;
29     if (items.length > 1) {
30         index = partition(items, left, right);
31         if (left < index - 1) {
32             quickSort(items, left, index - 1);
33         }
34         if (index < right) {
35             quickSort(items, index, right);
36         }
37     }
38     return items;
39 }
40 
41 var items = [3,8,7,2,9,4,10]
42 var result = quickSort(items, 0, items.length - 1);

　　3.插入排序

　　1.原理

　　將一組資料分成倆組，暫時叫做有序組和待插入組。每次從待插入組中取出一個元素，與有序組的元素進行比較，並找到合適的位置，將該元素插到有序組當中。就這樣，每次插入一個元素，有序組增加，待插入組減少。直到待插入組元素個數為0。當然，插入過程中涉及到了元素的移動。

　　2.過程

　　　（1）將陣列的第一個數作為有序組，其他數作為待插入組

　　　（2）從待插入組依次與有序組中的數進行對比，在合適位置插入

　　　（3）直到待插入組為空

 1 function insertionSort(arr) {
 2     var len = arr.length;
 3     var preIndex, current;
 4     for (var i = 1; i < len; i++) {//從1開始，陣列從第二個數開始作為待插入組
 5         preIndex = i - 1;
 6         current = arr[i];
 7         while(preIndex >= 0 && arr[preIndex] > current) {
 8             arr[preIndex+1] = arr[preIndex];
 9             preIndex--;
10         }
11         arr[preIndex+1] = current;
12     }
13     return arr;
14 }

　　4.選擇排序

　　1.原理

　　選擇排序改進了氣泡排序，每次遍歷列表只做一次交換，為了做到這一點，一個選擇排序在遍歷時尋找最大(小)的值，並在完成遍歷後，將其放到正確的地方。

　　2.過程

　　（1）第一輪從arr[0]~arr[n-1]中找到最小的元素，與arr[0]進行交換；
　　（2）第二輪從arr[1]~arr[n-1]中找到最小的元素，與arr[1]進行交換；
　　　　…
　　（3）依次類推，經過n-1輪之後，就形成了有序序列

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     // 尋找最小的數
                minIndex = j;                 // 將最小數的索引儲存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

　　5.時間複雜度空間複雜度對比

　　　在氣泡排序，插入排序，選擇排序，快速排序中，在最最壞情況下，快速排序的時間複雜為O(n2) ，插入排序O(n2)，選擇排序O(n2)，氣泡排序O(n2)