异常异常引荐人人去读一本gitBook上的书 – 十大典范排序算法 : https://sort.hust.cc/ ， 本文的动图和演示代码均是这内里的。
做编程，排序是个必定的需求。前端也不破例，虽然不多，然则你肯定会碰到。
不过说到排序，最轻易想到的就是冒泡排序，挑选排序，插进去排序了。
冒泡排序
顺次比较相邻的两个元素，假如后一个小于前一个，则交流，如许重新至尾一次，就将最大的放到了末端。
重新至尾再来一次，由于每举行一轮，末了的都已是最大的了，因今后一轮须要比较次数能够比上一次少一个。虽然你照样能够让他重新至尾来比较，然则背面的比较是没有意义的无用功，为了效力，你应当对代码举行优化。
图片演示以下：
代码完成：
function bubbleSort(arr) {
var len = arr.length;
for (var i = 0; i < len - 1; i++) {
for (var j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j+1]) { // 相邻元素两两对照
var temp = arr[j+1]; // 元素交流
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}挑选排序
挑选排序我以为是最简朴的了，大一学VB的时刻，就只记着了这个排序要领，道理异常简朴：每次都找一个最大或许最小的排在最先即可。
首先在未排序序列中找到最小（大）元素，寄存到排序序列的肇端位置
再从盈余未排序元素中继承寻觅最小（大）元素，然后放到已排序序列的末端。
反复第二步，直到一切元素均排序终了。
动图演示：
代码演示：
function selectionSort(arr) {
var len = arr.length;
var minIndex, temp;
for (var i = 0; i < len - 1; i++) {
minIndex = i;
for (var j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) { // 寻觅最小的数
minIndex = j; // 将最小数的索引保留
}
}
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr;
}插进去排序
插进去排序也比较简朴。就像打扑克一样，顺次将拿到的元素插进去到正确的位置即可。
将第一待排序序列第一个元素看作一个有序序列，把第二个元素到末了一个元素当做是未排序序列。
重新至尾顺次扫描未排序序列，将扫描到的每一个元素插进去有序序列的恰当位置。（假如待插进去的元素与有序序列中的某个元素相称，则将待插进去元素插进去到相称元素的背面。）
动图演示：
代码示例：
function insertionSort(arr) {
var len = arr.length;
var preIndex, current;
for (var i = 1; i < len; i++) {
preIndex = i - 1;
current = arr[i];
while(preIndex >= 0 && arr[preIndex] > current) {
arr[preIndex+1] = arr[preIndex];
preIndex--;
}
arr[preIndex+1] = current;
}
return arr;
}简朴的价值是低效
上面三种都是异常简朴的排序要领，简朴的同时呢，效力也会比较低，照样拿这本书里的对照图来申明：
时候复杂度都高达O(n^2),而它们背面的一些排序算法时候复杂度基础都只要O(n log n)。
我的强迫症又犯了，我想要高效力一点的排序要领。
兼并排序
简朴把这本书的内容过了一遍，当时就明白了这个兼并排序，因而这里就谈一下这个兼并排序吧。
基础道理是分治法，就是离开而且递返来排序。
步骤以下：
请求空间，使其大小为两个已排序序列之和，该空间用来寄存兼并后的序列；
设定两个指针，最初位置分别为两个已排序序列的肇端位置；
比较两个指针所指向的元素，挑选相对小的元素放入到兼并空间，并挪动指针到下一位置；
反复步骤 3 直到某一指针到达序列尾；
将另一序列剩下的一切元素直接复制到兼并序列尾。
动图演示：
代码示例：
function mergeSort(arr) { // 采纳自上而下的递归要领
var len = arr.length;
if(len < 2) {
return arr;
}
var middle = Math.floor(len / 2),
left = arr.slice(0, middle),
right = arr.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right)
{
var result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
while (left.length)
result.push(left.shift());
while (right.length)
result.push(right.shift());
return result;
}
既然是个爱折腾的人，折腾了总得看看效果吧。
效力测试
由于我学这个来举行排序不是对简朴数组，数组内都是对象，要对对象的某个属性举行排序，还要斟酌升降序。
因而我的代码完成以下：
/**
* [兼并排序]
* @param {[Array]} arr [要排序的数组]
* @param {[String]} prop [排序字段，用于数组成员是对象时，根据其某个属性举行排序，简朴数组直接排序疏忽此参数]
* @param {[String]} order [排序体式格局 省略或asc为升序 不然降序]
* @return {[Array]} [排序后数组，新数组，并非在原数组上的修正]
*/
var mergeSort = (function() {
// 兼并
var _merge = function(left, right, prop) {
var result = [];
// 对数组内成员的某个属性排序
if (prop) {
while (left.length && right.length) {
if (left[0][prop] <= right[0][prop]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
} else {
// 数组成员直接排序
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
}
while (left.length)
result.push(left.shift());
while (right.length)
result.push(right.shift());
return result;
};
var _mergeSort = function(arr, prop) { // 采纳自上而下的递归要领
var len = arr.length;
if (len < 2) {
return arr;
}
var middle = Math.floor(len / 2),
left = arr.slice(0, middle),
right = arr.slice(middle);
return _merge(_mergeSort(left, prop), _mergeSort(right, prop), prop);
};
return function(arr, prop, order) {
var result = _mergeSort(arr, prop);
if (!order || order.toLowerCase() === 'asc') {
// 升序
return result;
} else {
// 降序
var _ = [];
result.forEach(function(item) {
_.unshift(item);
});
return _;
}
};
})();须要对哪一个属性举行排序是不确定，能够随便指定，因而写成了参数。有由于不想让这些东西在每次轮回都举行推断，因而代码有点冗余。
关于降序的题目，也没有到场参数中，而是简朴的升序后再逆序输出。原因是不想让每次轮回递归里都去推断前提，所以简朴处理了。
下面就是见证效力的时刻了，一段数据模仿：
var getData = function() {
return Mock.mock({
"list|1000": [{
name: '@cname',
age: '@integer(0,500)'
}]
}).list;
};上面运用Mock举行了模仿数据，关于Mock ： http://mockjs.com/
现实测试来啦：
// 效力测试
var arr = getData();
console.time('兼并排序');
mergeSort(arr, 'age');
console.timeEnd('兼并排序');
console.time('冒泡排序');
for (var i = 0, l = arr.length; i < l - 1; ++i) {
var temp;
for (var j = 0; j < l - i - 1; ++j) {
if (arr[j].age > arr[j + 1].age) {
temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
console.timeEnd('冒泡排序');举行了五次，效果以下：
// 兼并排序: 6.592ms
// 冒泡排序: 25.959ms
// 兼并排序: 1.334ms
// 冒泡排序: 20.078ms
// 兼并排序: 1.085ms
// 冒泡排序: 16.420ms
// 兼并排序: 1.200ms
// 冒泡排序: 16.574ms
// 兼并排序: 2.593ms
// 冒泡排序: 12.653ms
最低4倍，最高近16倍的效力之差照样比较满意的。
虽然1000条数据让前端排序的可能性不大，然则几十上百条的状况照样有的。别的由于node，JavaScript也能运转的效劳端了，这个效力的提拔也照样有用武之地的。
一点疑问
兼并排序内里运用了递归，在《数据结构与算法 JavaScript 形貌》中，作者给出了自下而上的迭代要领。然则关于递归法，作者却以为：
However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.
但是，在 JavaScript 中这类体式格局不太可行，由于这个算法的递归深度对它来说太深了。
gitbook上这本书的作者对此有疑问，我也有疑问。
兼并中虽然用了递归，然则他是放在return后的呀。关于在renturn后的递归是有尾递归优化的呀。
关于尾递归优化是指：原本外层函数内部再挪用一个函数的话，由于外层函数须要守候内层函数返回后才返回效果，进入内层函数后，外层函数的信息，内存中是必需记着的，也就是挪用客栈。而内部函数放在return症结字后，就示意外层函数到此也就完毕了，进入内层函数后，没有必要再记着外层函数内的一切信息。
上面是我的明白的形貌，不知道算不算正确。chrome下已能够开启尾递归优化的功用了，我以为这个递归是不应影响他在JavaScript下的运用的。
末了
有兴致的话，引荐读读这本书，举行排序的时刻，能够斟酌一些更高效的要领。
不过须要注重的是，这些高效力的排序要领，平常都须要相对较多的分外内存空间，须要衡量一下。
别的，异常小规模的数据就没有必要了。一是影响太小，而是我们人的效力题目，一分钟能重新写个冒泡、挑选、插进去的排序要领，而换成是兼并排序呢？
原文宣布在我的博客JavaScript排序，不只是冒泡，迎接接见！
