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) 不稳定

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