大家好，又见面了，我是你们的朋友全栈君。

原生js数组排序

js 排序 以正序为例（即由小到大）

var arr = [0,2,1,4,3,9,6,5,7,8];  // 未排序的数组
var sortArr = null;  // 排序后得到的数组

1 sort排序

sortArr = arr.sort(function (a,b) {
	return a - b 
})

sort是es3增加的数组方法，大家可以放心使用（支持到ie6），但是数组在原数组上进行排序，不生成副本。这个时候我们的sortArr === arr是同一个数组

2 普通for循环排序

function sort (arr) {
	var newArr = [arr[0]];
	var nl = newArr.length;
	var ol = arr.length;
	for (var i = 1; i <= ol - 1; i++) {
		nl = newArr.length;
		for (var j = 0;  j <= nl - 1; j++) {
			if(newArr[j]>=arr[i]){
				newArr.splice(j, 0, arr[i]);
				break;
			}else if(j == nl - 1){
				newArr.push(arr[i])
			}
		}
	}
	return newArr;
}
sortArr = sort(arr);

*此方法会重新生成一个数组，并对其进行排序，但是缺点是执行效率低，当数据量较大时，*强烈不建议使用此方法。

3 二分法排序

function twoSort (arr) {
	var len = arr.length;
	var left = 0, right = 0, point = 0;   //定义三个标记位，point就是最中间的位置
	var nArr = [];
	nArr[0] = arr[0];         //定义一个数组后，把arr中第一个数先赋给nArr
	for(var i=1; i<len; i++){
		left = 0;
		var nLen = nArr.length;
		right = nLen;
		for(var j=0; j<nLen; j++){
			point = Math.floor((left + right)/2);   //取整
				if(nArr[point] < arr[i]){
					left = point + 1;          //注意必须加1
				}else{
					right = point;
				}
			if(right == left){        //如果right和left相等就表示找到了插入的位置 ，插入后，跳出循环
				nArr.splice(left,0,arr[i]);
				break;
			}
		}
	}
	return nArr;
}
sortArr = sort(arr);

此方法会重新生成一个数组，并对其进行排序，并且执行效率较高,但是代码量比较大，对于我们这种爱研(de)究(se)的同学来说是不会满足于此的。

4 递归二分法排序的两种写法

法1

function recursiveSort1(arr) {
	if (arr.length <= 1) { return arr; }//如果输入数组长度小于等于1，直接返回数组。这也是递归算法的终结部分
		var base = Math.floor(arr.length / 2);//找到中间的基准元素位置
		var baseEle = arr.splice(base, 1)[0];//把基准元素从arr中摘除
		var left = [];
		var right = [];
	for (var i = 0; i < arr.length; i++) {
		if (arr[i] < baseEle) {
			left.push(arr[i]);
		} else {
			right.push(arr[i]);
		}
	}
	return recursiveSort(left).concat([baseEle ], recursiveSort(right));
	//返回递归左右两个部分concat中间元素，这就是结果
};
sortArr = recursiveSort1(arr);

法2

function recursiveSort2(arr) {
	if (arr.length <= 1) { return arr; }//如果输入数组长度小于等于1，直接返回数组。这也是递归算法的终结部分
		var base = Math.floor(arr.length / 2);//找到中间的基准元素位置
		var baseEle = arr[base];//把基准元素从arr中取出
		var left = [];
		var right = [];
	for (var i = 0; i < arr.length; i++) {
		if (i === base) continue;
		if (arr[i] < baseEle) {
			left.push(arr[i]);
		} else {
			right.push(arr[i]);
		}
	}
	return recursiveSort(left).concat([baseEle ], recursiveSort(right));
	//返回递归左右两个部分concat中间元素，这就是结果
};
sortArr = recursiveSort1(arr);

这两种方法会重新生成一个数组，并对其进行排序，并且执行效率较高,代码量比较小。但是法1会改变原数组（剔除原数组中间的一个元素），法2会保留原数组