常见排序算法（js实现）

交换两个元素的值

unction swap(i,j){
    var tmp;
    tmp = i;
    i = j;
    j = tem;
}

一、冒泡排序
不断比较相邻两个元素的值，遍历一次，将最大（小）值冒泡到序列尾部（开头）

//冒泡排序
fucntion bubbleSort(arr){
    var len = arr.length;
    for(var i = 0; i < len; i++){
        for(var j = 0; j < len - 1 -i; j++){
            if(arr[j]>arr[j]+1){
                swap(arr[j],arr[j+1]);
            }
        }
    }
    return arr;
}

算法改进1：可以设置一个pos值，用于记录每次冒泡最后一次比较的位置，下次冒泡是只用比较到pos处即可

function bubbleSort2(arr) {
    console.time('改进后冒泡排序耗时');
    var i = arr.length-1;  //初始时,最后位置保持不变
    while ( i> 0) {
        var pos= 0; //每趟开始时,无记录交换
        for (var j= 0; j< i; j++)
            if (arr[j]> arr[j+1]) {
                pos= j; //记录交换的位置
                swap(arr[j],arr[j+1]);
            }
        i= pos; //为下一趟排序作准备
     }
     console.timeEnd('改进后冒泡排序耗时');
     return arr;
}

算法改进2：在每次遍历是使用双向冒泡，遍历一次，可以同时得到最大的一个和最小的一个值

//冒泡改进2
function bubble(arr){
    var len = arr.length;
    //设置标志位
    var low=0,
        height=len-1;
    while(low < height){
        //正向冒泡
        for(var i=low;i<height;i++){
            if(arr[i]>arr[i]+1){
                swap(arr[i],arr[i+1]);
            }
        }
        //反向冒泡
        for(var i=height;i>low;i--){
            if(arr[i]<arr[i-1]){
                swap(arr[i],arr[i-1]);
            }
        }
    }
    return arr;

}

二、选择排序（简单排序）
从未排序序列中找出最小（大）值，放入已排序序列开头，继续在未排序序列中找到最小（大）值，放入已排序序列的末尾

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;                 //将最小数的索引保存
            }
        }
       swap(arr[i],arr[minIndex];
    }
    return arr;
}

三、插入排序
从起始位的下一位开始，逐个将元素插入到已排序的序列中去（起始一个元素当然是有序的）

function insertSort(arr){
    var len=arr.length;
    for(var i=1;i<len;i++){
        for(var j=i;j>0;j--){
            var key = arr[j];
            if(arr[j]>key){
                arr[j+1]=arr[j];
            }
        }
        arr[j+1]=key;
    }
}

改进：在插入到一排序序列时，可以使用二分查找
四、希尔排序
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/5) {          //动态定义间隔序列
        gap =gap*5+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/5)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

五、归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

function mergeSort(arr) {  //采用自上而下的递归方法
    var len = arr.length;
    if(len < 2) {
        return arr;
    }
    var middle = Math.floor(len / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right)
{
    var result = [];
    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            result.push(left.shift());
        } else {
            result.push(right.shift());
        }
    }
    while (left.length)
        result.push(left.shift());
    while (right.length)
        result.push(right.shift());
    return result;
}

六、快速排序
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

function quickSort(array, left, right) {
    if (left < right) {
          var x = array[right], i = left - 1, temp;
          for (var j = left; j <= right; j++) {
              if (array[j] <= x) {
                  i++;
                  swap(a[i],a[j]);
              }
          }
          quickSort(array, left, i - 1);
          quickSort(array, i + 1, right);
      }
      return array;
 }

七、堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
八、计数排序
计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。适合于对大量重复的序列进行排序。它只能对整数进行排序。
九、桶排序
桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排。
十、基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
参考文章