基礎算法學習之排序篇（js實現）

1，最近在看 啊哈算法，覺得很有趣，特把其中有意思的算法記下來，

簡易的桶排序法

var a =  new Array(2,5,3,4,6,8,4,4,2,9);
var b = new Array(10); //標記數組
var d = new Array();  //存放數組
var i,j;
for (i=0;i<=11;i++){
    b[i] =0;
}
for( i=0,j=1;i <=10;i++,j++){
     var c =a[i];
    b[c]++;
}
for (i=0;i<=10;i++){
    for (j =1;j<=b[i];j++) {
        d.push(i);
    }
}
console.log(d);

運行結果：
[ 2, 2, 3, 4, 4, 4, 5, 6, 8, 9 ]

 該算法實際是講一列數組中的所有數都標記在一個數組裏，最後在從小到大打印出現的次數所對應的數此算法優點是時間快，
 缺點是如果數組的範圍太過龐大就會出現異常，比如超過4 294 967 295。
 算法時間度爲O(M+N)

冒泡排序

var c = new Array(1,8,6,18,16,548,21,5,63);
var i,j;
for(j=0;j<c.length-1;j++){
    for (i = 0;i <=c.length-1;i++){
        if(c[i]>c[i+1]){
            var d = c[i+1];
            c[i+1] = c[i];
            c[i] = d;
        }
    }
}
console.log(c);

運行結果：

[ 1, 5, 6, 8, 16, 18, 21, 63, 548 ]

上面的冒泡算法實現是按照每次比較相鄰的兩個數，把較大的數放在較小數的後面，依次比較到數組的最後一項
這時會發現最大的一位數已經交換到最後一位，稱爲歸位，說明有一位數已經排好了，這一過程先稱爲一趟，接下來
接下來從新從數組的第一位開始相鄰比較，交換位置，歸位第二大的數，這樣總共要經歷n-1（假設有n個數組）趟。
該算法是雙重嵌套循環所以這個算法的時間複雜度O(N^2).
缺點是時間複雜度高，效率低。

快速排序

var e = new Array(13,45,4,45,3,1,53,87,1,5);
function quicksort(left,right) {
    var i,j,t,temp;
    if(left>right)return;
    temp = e[left];
    i=left;
    j=right;
    while (i!=j){
        while(e[j]>=temp && i <j){
            j--;
        }
        while(e[i]<=temp && i <j){
            i++;
        }
        if(i<j){
            t = e[i];
            e[i] = e[j];
            e[j] = t;
        }
    }
    e[left] =e[i];
    e[i] = temp;
    quicksort(left,i-1);
    quicksort(i+1,right);
    return;
}
quicksort(0,e.length-1);
console.log(e);

運行結果：

[ 1, 1, 3, 4, 5, 13, 45, 45, 53, 87 ]

快速排序法是採用“二分法”的思想，先用一個基數去比較，將要排序的數組分成兩分，然後通過遞歸一一將
所有基數歸位，具體過程如下
選取數組中最左邊的基數是13
1  5  4  1  3  13  53  87  45  45 這是第一趟的結果 可以看到13把數組分爲兩半，並且自己位置也排好稱爲歸位，接下來進入遞歸
1                                               選取的基數爲1,1歸位。接着在右遞歸
   3  4  1  5                                基數爲5，歸位，接着在左遞歸
   1  3  4                                    基數爲3，歸位，接着在左遞歸
   1                                            基數爲1，歸位，接着在右遞歸
           4                                    基數爲4，歸位，接着在基數13的右邊遞歸（實質是第一次的所有遞歸完成，進行下一步右遞歸）。
      ...（此處省略13以右排序，與左邊相同）
1  1  3  4  5  13 ...
快速排序算法優點是算法比較快速高效，由於基數取得是第一位，並不是每次都能將數組很好的“二分”所以它的平均算法的時間複雜度O(NlogN)。


快速排序算法是最常用的算法之一，JavaScript中sort()方法就是快速排序。