JS 实现排序算法

冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

var arr = [5, 4, 1, 3, 0, 2, 6];
var temp = null;
for (var i = 0; i < arr.length; i++) {
　　for (var j = 0; j < arr.length - i; j++) {
　　　　if (arr[j] > arr[j + 1]) {
　　　　　　temp = arr[j];
　　　　　　arr[j] = arr[j + 1];
　　　　　　arr[j + 1] = temp;
　　　　}
　　　　console.log(arr);
　　　　}
　　console.log(`第${i+1}次循环冒出的最大值是${arr[arr.length - i-1]}`)
}

选择排序

• 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
• 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
• 以此类推，直到所有元素均排序完毕。

var arr = [5, 4, 1, 3, 0, 2, 6];
var min = null;
var temp = null;
for (var j = 0; j < arr.length - 1; j++) {
　　min = j;
　　for (var i = j + 1; i < arr.length; i++) {
　　　　if (arr[i] < arr[min]) {
　　　　　　min = i;
　　　　}
　　}
　　temp = arr[j]
　　arr[j] = arr[min];
　　arr[min] = temp;
　　console.log(`第 ${j+1} 次循环`, arr);
}

插入排序

• 构建有序序列，未排序数据依次从已排序数据按从后往前比较，插入到合适的位置。

var arr = [1, 3, 5, 4];
var temp = null;
for (var i = 1; i < arr.length; i++) {
　　console.log(`insert插入的是${arr[i]}`)
　　for (var j = 0; j < i; j++) {
　　　　if (arr[i] > arr[j]) {
　　　　　　console.log(`插入${arr[j]}的坐标之前`)
　　　　　　temp = arr[i];
　　　　　　for (var k = i; k > j; k--) {
　　　　　　　　arr[k] = arr[k - 1]
　　　　　　}
　　　　　　arr[j] = temp;
　　　　　　console.log(arr);
　　　　　　break;
　　　　}
　　}
}

希尔排序

• 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
• 按增量序列个数 k，对序列进行 k 趟排序；
• 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。
• 增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

var arr = [5, 4, 8, 1, 3, 7, 0, 9, 2, 6];
function shellSort(arr) {
　　var len = arr.length;
　　var tmp = undefined;
　　var gap = Math.floor(len / 2);
　　while (gap >= 1) {
　　　　console.log(`此时的gap为：${gap}`)
　　　　for (var i = 0; i < len; i++) {
　　　　　　for (var j = i; j >= gap; j = j - gap) {
　　　　// console.log(`此时的j为：${j},此时的j-gap为：${j-gap}`)
　　　　　　　　if (arr[j] < arr[j - gap]) {
　　　　　　　　　　tmp = arr[j];
　　　　　　　　　　arr[j] = arr[j - gap];
　　　　　　　　　　arr[j - gap] = tmp;
　　　　　　　　　　console.log(`这个时候开始交换，${j}与${j-gap}交换后的数组`, arr)
　　　　　　　　}
　　　　　　}
　　　　}
　　　　gap = Math.floor(gap / 2);
　　}
　　return arr;
}
shellSort(arr);

快速排序

• 设定一个分界值，通过该分界值将数组分成左右两部分。
• 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
• 左边和右边的数据又可以取一个分界值独立排序，做类似处理。
• 重复上述过程，通过递归将两侧部分排好序后，再进行合并，整个数组的排序也就完成了。

var arr = [5, 4, 1, 3, 0, 2, 6];
var sort = function(arr) {
　　if (arr.length < 2) return arr;
　　var left = [];
　　var right = [];
　　for (var i = 1; i < arr.length; i++) {
　　　　if (arr[0] > arr[i]) {
　　　　　　left.push(arr[i]);
　　　　} else {
　　　　　　right.push(arr[i]);
　　　　}
　　}
　　console.log(left.concat(arr[0], right))
　　return sort(left).concat(arr[0], sort(right));
}
console.log(sort(arr));

归并排序

• 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
• 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
• 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
• 重复步骤 3 直到某一指针达到序列尾； 将另一序列剩下的所有元素直接复制到合并序列尾。

var arr = [5, 4, 2, 1, 3, 7, 0, 9, 8, 6];
var merge_sort = function(arr) {
　　if (arr.length < 2) return arr;
　　var mid = Math.floor(arr.length / 2);
　　var left = arr.slice(0, mid);
　　var right = arr.slice(mid);
　　var merge = function(left, right) {
　　　　var result = [];
　　　　console.log(left, right);
　　　　// 只要不存在空数组，就不断比较大小，将较小的数存放到result
　　　　while (left.length && right.length) {
　　　　　　result.push(left[0] <= right[0] ? left.shift() : right.shift());
　　　　　　console.log(`更新的result：${result}`)
　　　　}
　　　　console.log(left, right)
　　　　console.log(`最终的result：${result}`)
　　　　console.log(`左右合并：${left.concat(right)}`)
　　　　console.log(`全部合并：${result.concat(left.concat(right))}`)
　　　　return result.concat(left.concat(right))
　　　　}
　　return merge(merge_sort(left), merge_sort(right))
}
console.log(merge_sort(arr))