本文除了会带人人相识一些Array.prototypr.sort()要领(背面简写为sort()要领)的基础定义和用法以外，还会议论一下sort()要领究竟是运用的什么排序算法。简朴度娘了一下，网上的那些sort()要领详解文章，大多只说了sort()要领的用法。另有说sort()要领是运用冒泡法做的排序，这是毛病的。下面，我们发车！

sort()要领

  先来看看sort()要领的一些基础知识。已相识sort()要领的童鞋可以直接跳过这部份。

定义

sort() 要领在恰当的位置对数组的元素举行排序，并返回数组。 sort 排序不一定是稳固的。

语法

arr.sort()

arr.sort(compareFunction)

申明

1.假如没有指明 compareFunction ，那末元素会依据转换为的字符串的诸个字符的Unicode位点举行排序。

2.假如指清楚明了 compareFunction ，那末数组会依据挪用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：

   a.假如 compareFunction(a, b) 小于 0 ，那末 a 会被排列到 b 之前；
   b.假如 compareFunction(a, b) 即是 0 ， a 和 b 的相对位置稳定。(ECMAScript 规范并不保证这一行动，而且也不是一切浏览器都邑恪守,比方 Mozilla 在 2003 年之前的版本）；
   c.假如 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
  d. compareFunction(a, b)必需老是对雷同的输入返回雷同的比较效果，不然排序的效果将是不确定的。(应用这一特征，可完成随机排序)

3.假如数组包括undefined元素（元素值为undefined或元素末定义）

以上90%援用自MDN

实例

//例1.字母排序
var a = new Array("banna","watermelon","orange","apple");
s.sort(); 
console.log(a) //输出 ["apple", "banna", "orange", "watermelon"]
//没什么好说的，比较函数缺省，依据字母递次升序排序 a<b<o<w

//例2.转化为字母排序
var a=[11,2,44,3,5,6];
a.sort();
console.log(a) // [11, 2, 3, 44, 5, 6]
//申明第一条，数字转为字符串，"11"<"2"<"3"<"44"<"5"<"6"

//例3.数字排序
var a=[11,2,44,3,5,6];
a.sort(function(a,b){
    return a-b; //升序——当a<b时，a-b返回一个小于0的值。依据申明2-a，a会在b的前面，则完成了升序排序。反之假如想完成降序排序，return b-a即可。
});
console.log(a) //输出 [2, 3, 5, 6, 11, 44]

//例3.随机排序
var a=[11,2,44,3,5,6];
a.sort(function(a,b){
    return Math.random()>.5?-1:1; //依据申明2-c特征，完成随机排序
});
console.log(a) //每次运转的输出都差别

  以上是sort()要领的一些基础用法,MDN里另有更多的用法。下面我们来看看sort()要领究竟是怎样排序的。

sort()要领怎样完成排序

  怎样检察sort()要领是假如完成排序的呢？我们可以在比较函数里把a,b及数组输出一下，看看是不是可以看出运用的排序算法。

var arr=[1, 8, 3, 5, -1];
function compare(a,b){
    console.log(a,b,arr);
    return a-b;
}
arr.sort(compare);
/**
控制台输出
1 8 [1, 8, 3, 5, -1]
8 3 [1, 8, 3, 5, -1]
1 3 [1, 8, 8, 5, -1]
8 5 [1, 3, 8, 5, -1]
3 5 [1, 3, 8, 8, -1]
8 -1 [1, 3, 5, 8, -1]
5 -1 [1, 3, 5, 8, 8]
3 -1 [1, 3, 5, 5, 8]
1 -1 [1, 3, 3, 5, 8]
[-1,1, 3, 5, 8]
*/

  不知道同砚们有无看出什么端倪。横竖我一最先是什么都没有发明，那就剖析剖析咯。
  第一次1和8比较，1<8，不须要调解位置。
  第二次8和3比较，8>3，须要调解位置。然则这里没有交流位置，仅仅是8掩盖了3位置。这里就可以推断出不是纯真的运用了冒泡算法。
  第三是1和3比较，1<3，3替代了8的位置。什么鬼，几个意义？？？看到这里我也是示意不懂呀。那就继承往下看咯。
  第四是8和5比较，8>5，又仅仅是掩盖，没有交流位置。照样不懂，继承往下！
  第五是3和5比较，3<5，5替代了8的位置，不懂，继承往下！
  第六是8和-1比较，8>-1， 还仅仅是掩盖，继承往下！
  第七、八、九次，-1顺次和5，3，1做了比较，而且5，3，1都挪动了一次位置。等等，这怎样和插进去排序法有点类似。

  再试试一下

var arr=[1, 8, 9, 5, 2];
arr.sort(compare);
/**
控制台输出
1 8 [1, 8, 9, 5, 2]
8 9 [1, 8, 9, 5, 2]
9 5 [1, 8, 9, 5, 2]
8 5 [1, 8, 9, 9, 2]
1 5 [1, 8, 8, 9, 2]
9 2 [1, 5, 8, 9, 2]
8 2 [1, 5, 8, 9, 9]
5 2 [1, 5, 8, 8, 9]
1 2 [1, 5, 5, 8, 9]
[1, 2, 5, 8, 9]
*/

  没跑了，这就是插进去法。再捋捋，第一次冒泡完以后，前两位肯是有序的。第二次比较，假如发作位变化，a先向后挪动一名，b没有直接前移，而是经由过程插进去法找到准确的位置插进去，此时前三位有序。假如没有发作位置变化，申明此时前三位已有序，继承拿有序的末了一名和以后的一名比较。云云轮回，直至全部数组有序。

  到这里，我们得出了结论：sort()要领是运用的冒泡和插进去两种体式格局连系举行排序的。 假如对排序不熟悉的同砚，可以看看——《十大典范排序算法》

  经一名大神的提示，EMCAScript并没有定义sort()要领运用的排序算法，各个浏览器完成的体式格局并不雷同。以上的结论我只在chrome和fireFox中存在。以上结论在chrome和fireFox也并不完全准确，当数组长度太长时，就不在是运用冒泡和插进去两种体式格局连系举行排序了，而是运用一种我不相识要领。先修正毛病的结论。等我弄清楚那种我不相识的要领，再来更新_srot()要领。

  童鞋你似不似认为到这里就完了，文章就圆满完毕了？固然不似!!!接下来,闲着没事我们模拟sort(),完成一个和sort()要领功用一样的自定义要领玩玩呀。

完成一个和sort()要领类似的_sort()要领

  这里不多说，直接上代码。然后看解释

Array.prototype._sort.f=function(a,b){ //设置默许依据Unicode位点举行排序
    a+="",b+="";
    return a<b?-1:a===b?0:1;
}

Array.prototype._sort=function(f){

    /**
    * 如未传入实参
    * 或传入的实参不是函数
    * 运用默许的排序函数 （按字符递次）
    */
    var f=f&&typeof(f)=="function"?f:Array.prototype._sort.f,
        len=this.length,
        i=0,
        t;
    /**
    * 这个轮回最先排序
    * Array.sort()运用的是一种冒泡各插进去连系的排序要领
    * 
    */
    for(i=0,t=undefined;i<len-1;i++){
        
        if(f(this[i],this[i+1])>0){ //大于零则须要交代位置
            t=this[i+1],this[i+1]=this[i];
        }
        
        /**
        * 假如t值是unfeined，
        * 则当前的此次骑比较没有发作位置变化
        * 也就不须要运用插进去法了
        */
        if(t){
            //运用插进去法找到准确的插进去位置，上面排序算法另有优化插进去法排序的要领
            for(var j=i-1;j>=0;j--){
            
                if(f(this[j],t)>0){//假如当前元素大于t,则当前元素后移一名
                
                    this[j+1]=this[j];
                    
                }else{//不然示意找到插进去点了，插进去t,并退出轮回
                
                    this[j+1]=t;
                    t=undefined;//将t设为undefined，防备冒泡未发作替代就进入插进去法排序
                    break;
                    
                }
            }                        
        }            
    }
    return this; //返回排序后的新数组
}

  到这里就完了？？？No!No!No!虽然我们完成了_sort()要领，然则另有一个不圆满的处所。申明第三点说了对undefined的处置惩罚划定规矩，我们还没有对unfined举行任何处置惩罚呢。还须要在上面的排序轮回最先之前增加如许一段。

//这个轮回把一切数组undefined的元素和数组末了一个不是undefined的元素替代
//差别浏览器对undefined处置惩罚体式格局差别，这里模拟chrome的处置惩罚体式格局
for(;i<len;i++){ 

    if(this[i]===undefined){ //
    
    /**
    * while找到末了一个(len-1)不是undefined的元素的下标
    * 同时更新须要排序的元素个数(len)
    * 那些个undefined就不鸟它了
    * 下标小于i的元素已搜检替代完成了，不须要再反复一次。所以增加一个len>=i的前提
    */
    while(this[len-1]===undefined&&len>=i){ 
        len--;
    }
    
    /**
    * 假如len即是i
    * 就示意下标不小于i的元素都是undefined了
    * 可以不必继承遍历了
    */
    if(len===i) break; 
    
    /**
    * 运用t将末了一个不是undefined的元素保存起来
    * i in this 是推断这个元素是不存在，照样值是undefined
    * 数组中一个不存在的元素，也会返回undefined(希罕数组)
    * 这两者照样有区分的
    * 假如不存在i in this会返回 false
    */
    t=this[len-1];
    if(i in this)
        this[len-1]=undefined; //元素值为undefined，直接将要替代元素值设为undefined
    else
        delete this[len-1]; //元素不存在，经由过程删除将要替代的元素设置为不存在，
    
    this[i]=t; //替代undefined元素
    
    //又塞了一个undefinef到背面，所以要排序的元素又少了一个，再减减一下
    len--; 
    
    }

}

  到这里是真完毕了，感谢人人！怎样有什么我说错了或许没申邃晓的处所，迎接人人留言一同议论，人人一同进修，共同进步么。