排序的道理：

1. 所有递归和循环可以互相转换
2. 循环时如果想不清楚i<arr.length还是i<arr.length+-1,就自己画画表确定
3. 不处理长度小于2的数组，如果有直接return
4. debug的时候要不断console.log大法，记得加标记

选择排序

let swap = (array, i, j) => {
  let temp = array[i]
  array[i] = array[j]
  array[j] = temp
}
let minIndex = arr => {//保证minindex是最小的下标
  let index = 0
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] < arr[index]) {
      index = i
    }
  }
  return index
}
let sort = arr => {
  for (let i = 0; i < arr.length; i++) {//老师说是length-1，但是我length也运行成功了
    let index = minIndex(arr.slice(i)) + i//保证下标位数不缺失
    if (index !== i) {
      swap(arr, index, i)
    }
  }
  return arr
}

# 快速排序
## 原理
比某数大的去后面，比某数小的去前面，一般会选择最中间那个数字作为基准点
![快速排序](https://img.haomeiwen.com/i19247518/03a1cdd8b823a409.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## 代码

let quickSoft = arr => {
if (arr.length <= 1) {//永远不处理长度<2的数组
return arr
} else {
let right == []
let left = []
let pivotIndex = Math.floor(arr.length - 1)/floor的作用是向下取整，如3.5floor后是3，pivot是中心点的意思
splice这个mdn通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。/

let pivot = arr.splice(pivotIndex, 1)[0]
for (i = 0; i < arr.length; i++) {
  arr[i] < pivot ? left.push(arr[i]) : right.push(arr[i])
}return quickSoft(left).concat([pivot],quickSoft(right))

}
}

## tips：
1. splice举例

let months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ['Jan', 'Feb', 'March', 'April', 'June']

months.splice(4, 1, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ['Jan', 'Feb', 'March', 'April', 'May']

2. Math是最特殊的对象，只有他一个人是首字母大写的对象，其他首字母大写的都是函数
# 合并排序
## 原理：就是不断的左边右边比

先是12，3，7，21自己内部比，分裂出12，3和7，21两个，再各自比，就有了3，12和2，21两个数组，然后用左边第一个和右边第一个比，就是3和7比，3小踢出去；用12和7比，7小踢出去，再用12和21比，12小踢出去，所以排序就按照踢出去的先后排序即可，然后不断向上循环。
![合并排序eg1](https://img.haomeiwen.com/i19247518/91cdbc788b9075ec.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
## 代码

let merge = (a, b) => {
if (a.length === 0) {
return b
}
if (b.length === 0) {
return a
}
return a[0] < b[0] ? [a[0]].concat(merge(b, a.slice(1))) : [b[0]].concat(merge(a, b.slice(1)))
}
let b = [1, 22, 33, 12, 31]
let mergeSoft = arr => {
let k = arr.length
if (k === 1) {
return arr
}
if (k > 1) {
console.log("----")
let left = arr.slice(0, Math.floor(k / 2))
let right = arr.slice(Math.floor(k / 2)) //从最中间开始切

return merge(mergeSoft(left), mergeSoft(right)) //此时merge还没有写出来，现在这里占位置}

}
}

![merge的递归循环代入法](https://img.haomeiwen.com/i19247518/f41965dc3ae73247.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
## Tips
1. slice的详细情况：slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

let animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

# 计数排序
## 原理
像是发牌的时候，从A-K，每种牌放一堆，就可以把所以四张牌挑出来
这里是使用了哈希表记录，发现数字N共m次，记作N：m
## 代码

let countSort = arr => {
let hashTable = {}
max = 0
result = []
for (let i = 0; i < arr.length; i++) {
if (!(arr[i] in hashTable)) {
hashTable[arr[i]] = 1
}
else {
hashTable[arr[i]] += 1
}
if (arr[i] > max) {
max = arr[i]
}
}
console.log(hashTable)
for (let j = 0; j <= max; j++) {
if (j in hashTable) {
for (let i = 0; i < hashTable[j]; i++) {
console.log(----)
console.log(hashTable[j])
result.push(j)
}
}
}
console.log(max)
return result
}

## Tips
1. 
# 四种排序方法的时间复杂度