Font-end（排序算法）

各种排序及其复杂度

插入排序（稳定）

function insertSort(arr){    var temp;    for( var i = 1 ; i <= arr.length-1 ; i++){        //取出"分界线"右边第一位，作为temp（本轮循环就你了）        temp = arr[i];        //设"分界线"左边第一位的下标，作为j        j = i-1;        while(j>=0 && arr[j] > temp){            arr[j+1] = arr[j];//二话不说，直接后挪一位            --j;        }        //挪后插        arr[j+1] = temp;    }    return arr;}

思想：
0、分“有序组”（左手已拿到并已排序的牌）、“无序组”（右手抽到的牌）；
1、起初“分界线”在下标0和1之间；
2、取“分界线”右边第一位，作为temp（分界线后面的，在本轮先不管，因为表示还没抽到的牌啦）；
3、设“分界线”左边第一位的下标，作为 j；
4、j = i-1，这样 j 就离 i 更近了；
5、当 j >= 0 ，并且 arr[ j ] > temp，可插，那就二话不说，直接将那大块只挪到后一位。被大块只覆盖掉的朋友你别怕，你肯定是已经被抽取出来的啦；
6、然后再while循环，如果没有再出现比你这个temp大的还好；若有，这“第二大块只”也直接覆盖掉刚刚“大块只”的地方。不用担心，大块只已早就分身有术了；这时候 j 已跑在前沿了~
7、好啦，如果再没有出现过，那就是不用循环了；将arr[ j+1 ] = temp；temp要的位置就是你啦！
8、然后将分界线向右走一个单位，重复2~7，假装又取了一张牌；

快速排序（不稳定！）

function quickSort(arr){            //如果数组<=1,则直接返回            if(arr.length<=1){return arr;}            var pivotIndex=Math.floor(arr.length/2);            //找基准，并把基准从原数组删除            var pivot=arr.splice(pivotIndex,1)[0];            //定义左右数组            var left=[];            var right=[];            //比基准小的放在left，比基准大的放在right            for(var i=0;i<arr.length;i++){                if(arr[i]<=pivot){                    left.push(arr[i]);                }                else{                    right.push(arr[i]);                }            }            //递归            return quickSort(left).concat([pivot],quickSort(right));        }                

选择排序（不稳定！）

function selectSort(arr){    var min,temp;    for(var i = 0 ; i < arr.length-1 ; i++){        min = arr[i];        for(var j = i+1; j < arr.length ; j++){            if(arr[j] < min){                temp = min;                min = arr[j];                arr[j] = temp;            }        }        arr[i] = min;    }    return arr;}

思想：
0、一共会进行 arr.length - 1轮的比赛；
1、从左边第一个数（即 i=0）开始，拷贝他，作为“天选之子”放到min；
2、将它后面一直觊觎着这个皇位的人，一个个和这个min比较。谁赢了，谁也拷贝一份做min，然后将min扔到走掉的那个人的位置，一直到最后一个觊觎的小人；
3、就在本次循环后，min里的数，放到当前的i处；
4、本轮比赛结束，i++

冒泡排序（稳定）

    var arr = [2,88,6,8,3,0,34,72];    var sort = {};    sort.bubbleSort = function (arr) {        if (arr.length <= 1) {            return arr;        }        //i表示比较的轮数        for (var i = 0; i < arr.length - 1; i++) {            //比较i轮，把i个最大数放在数组后面，排数这i个数            for (var j = 0; j < arr.length - 1 - i; j++) {                if (arr[j] > arr[j + 1]) {                    var temp = arr[j];                    arr[j] = arr[j + 1];                    arr[j + 1] = temp;                }            }            console.log("第" + i + "轮:arr=[" + arr + "]");        }    };    sort.bubbleSort(arr);    console.log(arr);    第0轮:arr=[2,6,8,3,0,34,72,88]    第1轮:arr=[2,6,3,0,8,34,72,88]    第2轮:arr=[2,3,0,6,8,34,72,88]    第3轮:arr=[2,0,3,6,8,34,72,88]    第4轮:arr=[0,2,3,6,8,34,72,88]    第5轮:arr=[0,2,3,6,8,34,72,88]    第6轮:arr=[0,2,3,6,8,34,72,88]    [0, 2, 3, 6, 8, 34, 72, 88]

希尔排序（不稳定！）

function shallSort(array) { var increment = array.length; var i var temp; //暂存 var count = 0; do {    //设置增量   increment = Math.floor(increment / 3) + 1;   for (i = increment ; i < array.length; i++) {    console.log(increment);     if (array[i] < array[i - increment]) {       temp = array[i];       for (var j = i - increment; j >= 0 && temp < array[j]; j -= increment) {           array[j + increment] = array[j];       }       array[j + increment] = temp;     }   } } while (increment > 1) return array;}

归并排序（稳定）

归并排序：其基本思想是分治策略，先进行划分，然后再进行合并。
假设要对数组C进行归并排序，步骤是：
1.先将C划分为两个数组A和B（即把数组C从中间分开）
2.再分别对数组A、B重复步骤1的操作，逐步划分，直到不能再划分为止(每个子数组只剩下一个元素)，这样，划分的过程就结束了。

function merge(left, right) {      var result = [];      while(left.length > 0 && right.length > 0) {         if(left[0] < right[0]) {             result.push(left.shift());         }         else {             result.push(right.shift());         }     }     /* 当左右数组长度不等.将比较完后剩下的数组项链接起来即可 */     return result.concat(left).concat(right);  }      function mergeSort(arr){          if(arr.length==1) {return arr};          var mid=Math.floor(arr.length/2);          var left_arr=arr.slice(0,mid),right_arr=arr.slice(mid);          return merge(mergeSort(left_arr),mergeSort(right_arr));      }      var arr=[12,20,30,21,15,33,26,19,40,25];      console.log(mergeSort(arr));  

堆排序（不稳定）

基数排序（稳定）