基础算法学习之排序篇（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()方法就是快速排序。