几种算法排序
整理里几种算法排序，代码如下
选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
console.log("====选择排序====")
let arr1 = [5, 2, 4, 8, 1, 3, 6]
let indexMin = (numbers) => {
let index = 0
for (let i = 1; i < numbers.length; i++) {
if (numbers[i] < numbers[index]) {
index = i
}
}
return index
}
let swap = (numbers, i, j) => {
const number = numbers[i]
numbers[i] = numbers[j]
numbers[j] = number
}
let sort1 = (numbers) => {
if (numbers.length <= 1) { return numbers }
for (let i = 0; i < numbers.length - 1; i++) {
const index = indexMin(numbers.slice(i)) + i
swap(numbers, index, i)
}
return numbers
}
console.log(arr1)// [5, 2, 4, 8, 1, 3, 6]
console.log(sort1(arr1))// [1, 2, 3, 4, 5, 6, 8]
快速排序
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
以某某为基准 想象你是一个体育委员 你面对的同学为 [12, 3, 7, 21, 5, 9 4, 6] 「以某某为基准，小的去前面，大的去后面」 你只需要重复说这句话，就能排序
console.log("====快速排序====")
let arr2 = [5, 2, 4, 9, 1, 3, 6, 10]
let sort2 = arr => {
if (arr.length < 1) { return arr }
const index = Math.floor(arr.length / 2)
const number = arr.splice(index, 1)[0]
let left = []
let right = []
for (let i = 0; i < arr.length; i++) {
if (arr[i] < number) {
left.push(arr[i])
} else {
right.push(arr[i])
}
}
return sort2(left).concat([number], sort2(right))
}
console.log(arr2)// [5, 2, 4, 9, 1, 3, 6, 10]
console.log(sort2(arr2))//[1, 2, 3, 4, 5, 6, 9, 10]
归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
象你是一个体育委员 你面对的同学为 [12, 3, 7, 21, 5, 9 4, 6] 左边一半排好序，右边一半排好序 然后把左右两边合并(merge )起来
console.log("====归并排序====")
let arr3 = [5, 2, 4, 9, 1, 3, 6, 11, 10]
let sort3 = arr => {
let mergeSort = arr => {
const i = arr.length
if (i === 1) { return arr }
let left = arr.slice(0, Math.floor(i / 2))
let right = arr.slice(Math.floor(i / 2))
return merge(mergeSort(left), mergeSort(right))
}
let merge = (a, b) => {
if (a.length === 0) { return b }
if (b.length === 0) { return a }
return a[0] > b[0] ?
[b[0]].concat(merge(a, b.slice(1))) :
[a[0]].concat(merge(a.slice(1), b))
}
return mergeSort(arr)
}
console.log(arr3)// [5, 2, 4, 9, 1, 3, 6, 11, 10]
console.log(sort3(arr3))// [1, 2, 3, 4, 5, 6, 9, 10, 11]
计数排序
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
用一个哈希表作记录 发现数字 N 就记 N: 1，如果再次发现 N 就加1 最后把哈希表的 key 全部打出来，假设 N: m，那么 N 需要打印 m 次
算法描述
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
console.log("====计算排序====")
let arr4 = [15, 5, 2, 4, 2, 9, 1, 3, 6, 11, 10]
let sort4 = arr => {
let hash = {}
let max = 0
let array = []
for (let i = 0; i < arr.length; i++) {
if (!(arr[i] in hash)) {
hash[arr[i]] = 1
} else {
hash[arr[i]] += 1
}
if (arr[i] > max) { max = arr[i] }
}
for (let j = 0; j <= max; j++) {
if (j in hash) {
for (let k = 0; k < hash[j]; k++) {
array.push(j)
}
}
}
return array
}
console.log(arr4)//[15, 5, 2, 4, 2, 9, 1, 3, 6, 11, 10]
console.log(sort4(arr4))// [1, 2, 2, 3, 4, 5, 6, 9, 10, 11, 15]
插入排序
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
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;
希尔排序
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
算法描述
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
function shellSort(arr) {
var len = arr.length;
for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
// 注意：这里和动图演示的不一样，动图是分组执行，实际操作是多个分组交替执行
for (var i = gap; i < len; i++) {
var j = i;
var current = arr[i];
while (j - gap >= 0 && current < arr[j - gap]) {
arr[j] = arr[j - gap];
j = j - gap;
}
arr[j] = current;
}
}
return arr;
}
冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法描述
- 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
- 针对所有的元素重复以上的步骤，除了最后一个；
- 重复步骤1~3，直到排序完成。
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;
}
