javascript排序总结

关于这类的博客随便一百度一大堆，排序一直是算法的必备常识，这里我把排序用javascript语言总结了一下，算是复习了吧。

选择排序

var arr = [4,1,3,5,6,2,6,4,3,5,2,1];
for(var i = 0;i < arr.length - 1; i++){
    for(var j = i + 1;j < arr.length; j++){
        if(arr[i] > arr[j]){
            var temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}
console.log(arr);//[ 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 ]

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

冒泡排序

var arr = [4,1,3,5,6,2,6,4,3,5,2,1];
for(var i = 0;i < arr.length - 1; i++){
    for(var j = 0;j < arr.length - i - 1; j++){
        if(arr[j] > arr[j + 1]){
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}
console.log(arr);//[ 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 ]

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

双向冒泡

var arr = [4,1,3,5,6,2,6,4,3,5,2,1];
function highBubble() {
    var low = 0,high = arr.length;
    while(low < high){
        for(var i = low;i < high; i++){
            if(arr[i] > arr[i+1]) {
                var temp = arr[i+1];
                arr[i+1] = arr[i];
                arr[i] = temp;
            }
        }
        high--;
        for(var i = high;i > low; i--){
            if(arr[i] < arr[i-1]) {
                var temp = arr[i-1];
                arr[i-1] = arr[i];
                arr[i] = temp;
            }
        }
        low++;
    }
}
highBubble();
console.log(arr);//[ 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 ]

分别从左到右和从右到左进行冒泡排序，将普通冒泡排序的时间缩短了一半

快速排序

var arr = [4,1,3,5,6,2,6,4,3,5,2,1];
function quickSort(arr) {
    var left = [],right = [];
    var mid = Math.floor(arr.length/2);
    if (arr.length <= 1) { 
        return arr; 
    }
    var midVal = arr.splice(mid,1)[0];
    for(var i = 0;i < arr.length; i++){
        if(arr[i] > midVal){
            right.push(arr[i]);
        } else {
            left.push(arr[i]);
        }
    }
    return quickSort(left).concat(midVal,quickSort(right));
}
var arr = quickSort(arr);
console.log(arr);//[ 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 ]

从数组中取一个值为基准值，并将剩下的值与之比较，小于基准值的放到左边，大于基准值的放到右边，并再次对左右两边进行快速排序，直至左右两边只剩一个元素。

插入排序

var arr = [4,1,3,5,6,2,6,4,3,5,2,1];
function insertSort(arr) {  
    var len = arr.length,tmp,result;    
    result = arr.slice(0);  
    for(var i = 1; i < len; i++){  
        tmp = result[i];      
        var j = i - 1;           
        while(j >= 0 && tmp < result[j]){  
            result[j+1] = result[j];      
            j--;                          
        }  
        result[j+1] = tmp;    
    }             
    return result;  
} 
arr = insertSort(arr);
console.log(arr);//[ 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6 ]

数组第一个值为默认的衡量值,从第二个值开始与之前的值进行比较,之前比较过的数形成了一个有序的序列,如果满足有序序列有数且后面的第一个数,比有序序列的最后一个小那么进入插值过程,指针向前移动,重复这个过程寻找到它的合适位置。

希尔排序

var arr = [61,85,19,88,68,8,70,29];
function shellSort(){
      var gaps = [3,2,1];
        for(var g = 0;g < gaps.length; g++){
            for(var i = gaps[g];i < arr.length; i++){
                var temp = arr[i];
                for(var j = i;j >= gaps[g] && arr[j-gaps[g]] > temp; j -= gaps[g]){
                    arr[j] = arr[j - gaps[g]];
                }
                arr[j] = temp;
            }
        }
}
shellSort();
console.log(arr);//[ 8, 19, 29, 61, 68, 70, 85, 88 ]

定义一个间隔序列，例如是[3，2，1]。第一次处理，会处理所有间隔为3的，下一次会处理间隔为2的，最后一次处理间隔为1的元素。也就是相邻元素执行标准插入排序。先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

堆排序

function buildHeap(elements){
  for(var i = elements.length/2; i >= 0; i--){
    headAdjust(elements, i, elements.length);
  }
}
function sort(elements){
  buildHeap(elements);
  for(var i=elements.length-1; i>0; i--){
    var swap = elements[i];
    elements[i] = elements[0];
    elements[0] = swap;
    headAdjust(elements, 0, i);
  }
}
var elements = [3, 1, 5, 7, 2, 4, 9, 6, 10, 8];
sort(elements);
console.log(elements);//[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

buildHeap从最后一个拥有子节点的节点开始调整(将数组层次遍历)每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换（交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。

参考：http://blog.csdn.net/xiaoxiaoxuewen/article/details/7570621/

总结

排序方法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(n^2)	O(1)	稳定
双向冒泡排序	O(n^2)	O(1)	稳定
选择排序	O(n^2)	O(1)	稳定
快速排序	O(n*log2n)	O(log2n)~O(n)	不稳定
插入排序	O(n^2)	O(1)	稳定
希尔排序	O( )	O(1)	不稳定
堆排序	O(n*log2n)	O(1)	不稳定

希尔排序的时间复杂度与所选的时间间隔有关系