参考答案：
一. 冒泡排序
它是最慢的排序算法之一，但也是一种最容易实现的排序算法。
之所以叫冒泡排序是因为应用这种排序算法排序时，数据值会像气泡一样从数组的一端沉没到另一端。假如正在将一组数字依照升序排列，较大的值会浮动到数组的右侧，而较小的值则会浮动到数组的左侧。之所以会产生这种景象是因为算法会屡次在数组中挪动，比拟相邻的数据，当左侧值大于右侧值时将它们进行调换。
function BubbleSort(array) {
var length = array.length;
for (var i = length - 1; i > 0; i--) {
// 用于放大范畴
for (var j = 0; j < i; j++) {
// 在范畴内进行冒泡，在此范畴内最大的一个将冒到最初面
if (array[j] > array[j + 1]) {var temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
console.log(array);
console.log("-----------------------------");
}
return array;
}
var arr = [10, 9, 8, 7, 7, 6, 5, 11, 3];
var result = BubbleSort(arr);
console.log(result);
/*
[9, 8, 7, 7, 6, 5, 10, 3, 11]
-----------------------------
[8, 7, 7, 6, 5, 9, 3, 10, 11]
-----------------------------
[7, 7, 6, 5, 8, 3, 9, 10, 11]
-----------------------------
[7, 6, 5, 7, 3, 8, 9, 10, 11]
-----------------------------
[6, 5, 7, 3, 7, 8, 9, 10, 11]
-----------------------------
[5, 6, 3, 7, 7, 8, 9, 10, 11]
-----------------------------
[5, 3, 6, 7, 7, 8, 9, 10, 11]
-----------------------------
[3, 5, 6, 7, 7, 8, 9, 10, 11]
-----------------------------
[3, 5, 6, 7, 7, 8, 9, 10, 11]
*/二. 抉择排序
抉择排序从数组的结尾开始，将第一个元素和其余元素进行比拟。查看完所有元素后，最小的元素会被放到数组的第一个地位，而后算法会从第二个地位持续。这个过程始终进行，当进行到数组的倒数第二个地位时，所有数据便实现了排序。
function SelectionSort(array) {
var length = array.length;
for (var i = 0; i < length; i++) {
// 放大抉择的范畴
var min = array[i]; // 假设范畴内第一个为最小值
var index = i; // 记录最小值的下标
for (var j = i + 1; j < length; j++) {
// 在范畴内选取最小值
if (array[j] < min) {min = array[j];
index = j;
}
}
if (index != i) {
// 把范畴内最小值替换到范畴内第一个
var temp = array[i];
array[i] = array[index];
array[index] = temp;
}
console.log(array);
console.log("---------------------");
}
return array;
}
var arr = [1, 10, 100, 90, 65, 5, 4, 10, 2, 4];
var result = SelectionSort(arr);
console.log(result);
/*
[1, 10, 100, 90, 65, 5, 4, 10, 2, 4]
---------------------
[1, 2, 100, 90, 65, 5, 4, 10, 10, 4]
---------------------
[1, 2, 4, 90, 65, 5, 100, 10, 10, 4]
---------------------
[1, 2, 4, 4, 65, 5, 100, 10, 10, 90]
---------------------
[1, 2, 4, 4, 5, 65, 100, 10, 10, 90]
---------------------
[1, 2, 4, 4, 5, 10, 100, 65, 10, 90]
---------------------
[1, 2, 4, 4, 5, 10, 10, 65, 100, 90]
---------------------
[1, 2, 4, 4, 5, 10, 10, 65, 100, 90]
---------------------
[1, 2, 4, 4, 5, 10, 10, 65, 90, 100]
---------------------
[1, 2, 4, 4, 5, 10, 10, 65, 90, 100]
---------------------
[1, 2, 4, 4, 5, 10, 10, 65, 90, 100]
*/三. 插入排序
插入排序有两个循环。外循环将数组元素挨个挪动，而内循环则对外循环中选中的元素进行比拟。如果外循环中选中的元素比内循环中选中的元素小，那么数组元素会向右挪动，为内循环中的这个元素腾出地位。
function InsertionSort(array) {
var length = array.length;
for (var i = 0; i < length - 1; i++) {
// i 代表曾经排序好的序列最初一项下标
var insert = array[i + 1];
var index = i + 1; // 记录要被插入的下标
for (var j = i; j >= 0; j--) {if (insert < array[j]) {
// 要插入的项比它小，往后挪动
array[j + 1] = array[j];
index = j;
}
}
array[index] = insert;
console.log(array);
console.log("-----------------------");
}
return array;
}
var arr = [100, 90, 80, 62, 80, 8, 1, 2, 39];
var result = InsertionSort(arr);
console.log(result);
/*
[90, 100, 80, 62, 80, 8, 1, 2, 39]
-----------------------
[80, 90, 100, 62, 80, 8, 1, 2, 39]
-----------------------
[62, 80, 90, 100, 80, 8, 1, 2, 39]
-----------------------
[62, 80, 80, 90, 100, 8, 1, 2, 39]
-----------------------
[8, 62, 80, 80, 90, 100, 1, 2, 39]
-----------------------
[1, 8, 62, 80, 80, 90, 100, 2, 39]
-----------------------
[1, 2, 8, 62, 80, 80, 90, 100, 39]
-----------------------
[1, 2, 8, 39, 62, 80, 80, 90, 100]
-----------------------
[1, 2, 8, 39, 62, 80, 80, 90, 100]
*/四. 希尔排序
希尔排序 (Shell’s Sort) 是插入排序的一种又称“放大增量排序”（Diminishing Increment Sort），是间接插入排序算法的一种更高效的改良版本。希尔排序是非稳固排序算法。该办法因 D.L.Shell 于 1959 年提出而得名。
function shellSort(arr) {
let len = arr.length;
// gap 即为增量
for (let gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {for (let i = gap; i < len; i++) {
let j = i;
let current = arr[i];
while(j - gap >= 0 && current < arr[j - gap]) {arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = current;
}
console.log(arr);
console.log("-----------------------");
}
}
var arr = [3,5,7,1,4,56,12,78,25,0,9,8,42,37];
shellSort(arr);
/*
[3, 5, 0, 1, 4, 42, 12, 78, 25, 7, 9, 8, 56, 37]
-----------------------
[1, 4, 0, 3, 5, 8, 7, 9, 25, 12, 37, 42, 56, 78]
-----------------------
[0, 1, 3, 4, 5, 7, 8, 9, 12, 25, 37, 42, 56, 78]
-----------------------
*/五. 归并排序
归并排序把一系列排好序的子序列合并成一个大的残缺有序序列。咱们须要两个排好序的子数组，而后通过比拟数据大小，从最小的数据开始插入，最初合并失去第三个数组。然而，在理论状况中，归并排序还有一些问题，咱们须要更大的空间来合并存储两个子数组。
var array = [3,5,7,1,4,56,12,78,25,0,9,8,42,37];
console.log(array);
console.log("-----------------------");
var len = array.length;
sort(0,len);
console.log(array);
function sort(begin,end) {if (end - begin < 2) {return;}
let mid = (begin + end) >> 1;
sort(begin, mid);
sort(mid, end);
merge(begin,mid,end);
}
function merge(begin,mid,end) {
let li = 0,le = mid - begin;
let ri = mid,re = end;
let ai = begin;
let leftArray = [];
for (let i = li;i<le;i++) {leftArray[i] = array[begin + i];
}
while(li < le){if(ri < re && array[ri] < leftArray[li]){array[ai++] = array[ri++];
}else{array[ai++] = leftArray[li++];
}
}
}
/*
[3, 5, 7, 1, 4, 56, 12, 78, 25, 0, 9, 8, 42, 37]
-----------------------
[0, 1, 3, 4, 5, 7, 8, 9, 12, 25, 37, 42, 56, 78]
*/六. 疾速排序
疾速排序是解决大数据集最快的排序算法之一。它是一种分而治之的算法，通过递归的办法将数据顺次合成为蕴含较小元素和较大元素的不同子序列。该算法一直反复这个步骤直到所有数据都是有序的。
这个算法首先要在列表中抉择一个元素作为基准值(pivot)。数据排序围绕基准值进行，将列表中小于基准值的元素移到数组的底部，将大于基准值的元素移到数组的顶部。
function quickSort(arr, i, j) {if(i < j) {
let left = i;
let right = j;
let pivot = arr[left];
while(i < j) {while(arr[j] >= pivot && i < j) { // 从后往前找比基准小的数
j--;
}
if(i < j) {arr[i++] = arr[j];
}
while(arr[i] <= pivot && i < j) { // 从前往后找比基准大的数
i++;
}
if(i < j) {arr[j--] = arr[i];
}
}
arr[i] = pivot;
quickSort(arr, left, i-1);
quickSort(arr, i+1, right);
return arr;
}
}
let arr = [2, 10, 4, 1, 0, 9, 5 ,2];
console.log(quickSort(arr, 0 , arr.length-1));
/*
[0, 1, 2, 2, 4, 5, 9, 10]
*/