快速排序
核心算法：
1.取一个基准值（一般是数组中间的元素），遍历数组，比基准值大的放右边，小的放左边，相等的则不动
2.分别创建三个数组来存储元素，最后将三个数组拼接起来
3.循环调用函数，存储相等值的数组不变，其余两个数组作为函数参数
function quicksort(arr) {
if (arr.length <= 1) return arr
let baseValue = arr[Math.floor(arr.length / 2)]
let commonArr = []
let bigArr = []
let smallArr = []
arr.forEach(item => {
if (item === baseValue) {
commonArr.push(item)
} else if (item > baseValue) {
bigArr.push(item)
} else {
smallArr.push(item)
}
})
return quicksort(smallArr).concat(commonArr, quicksort(bigArr))
// 也可以写成：
// return [...quicksort(smallArr),...commonArr,...quicksort(bigArr)]
}
冒泡排序
核心算法：
1.循环遍历数组元素
2.挨在一起的两个元素进行比较，大的放后面，这样遍历一次数组后，最大的元素将放在最后面
function bubblesort(arr) {
const newArr = [...arr]
// i用于控制多少轮
for (let i = 0; i < newArr.length - 1; i++) {
for (let j = 0; j < newArr.length - 1 - i; j++) {
// 当前值大于后面的值，则对调位置
newArr[j] > newArr[j + 1] && ([newArr[j], newArr[j + 1]] = [newArr[j + 1], newArr[j]])
}
}
return newArr
}
选择排序
核心算法：
1.循环遍历每一个元素
2.每次选择一个元素，和后面的元素比较大小，如果后面的元素更小，则交换值。
function selectSort(arr) {
// 这层循环用于控制遍历的次数
for (let i = 0; i < arr.length; i++) {
// minIndex用来记录最小值所对应的索引
let minIndex = i
for (let j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) minIndex = j
}
// 如果找到更小的值，则调换位置
if (minIndex !== i) [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]
}
return arr
}
插入排序
思想一：
核心算法（类似于打牌，最终手上的牌按从小到大的顺序排好）：
1.先抽出一张牌放到手上，方便后续比较
2.每次抽出一张牌，都要和手上的牌进行比较，插到合适的位置。
3.如果比手上的某一张牌大，则插入到这张牌的后面；如果比较一轮后，没有找到合适的位置，则说明它是最小的，放到最前面
function insertSort(arr) {
let newArr = []
// 手里先拿一张牌
newArr.push(arr[0])
for (let i = 1; i < arr.length; i++) {
const A = arr[i]
// 抽出一张牌，从大到小和手里的牌进行比较
for (let j = newArr.length - 1; j >= 0; j--) {
const B = newArr[j]
// 比某一张牌大，则插入到这张牌的后面
if (A >= B) {
newArr.splice(j + 1, 0, A)
break
}
// 如果比较一轮后，不满足前面的条件，说明这张牌是最小的，则放到最前面
if (j === 0) newArr.unshift(A)
}
}
return newArr
}
思想二：
核心算法：
1.默认数组中的第一个元素为有序数组
2.依次遍历无序数组，每次取一个元素和有序数组中所有元素作比较，如果某个元素比它大，则后移一位
function insertSort(arr) {
// 认为第一个元素是有序的，所以不用遍历
for (let i = 1; i < arr.length; i++) {
let key = arr[i]
let j = i - 1
// 拿一个数和有序数组中的所有元素作比较
for (; j >= 0 && arr[j] > key; j--) {
// 如果元素比这个数大，则元素向后移动
arr[j+1] = arr[j]
}
// 这个数被插到合适的位置
arr[j+1] = key
}
return arr
}
希尔排序
核心算法（相当于是插入排序的升级版，无非就是在外面多嵌套一层循环）：
1.对相隔一定值的元素进行排序（刚开始一般是数组长度的一半），使数组相对有序
2.后面不断缩小这个值，直到为1（即最后会进行一次插入排序）
function shellSort(arr) {
let len = arr.length
let gap = Math.floor(len / 2)
while (gap) {
// 假设同组的第一个元素是有序的，遍历无序数组
for (let i = gap; i < len; i++) {
let key = arr[i]
let j = i - gap
// 用无序数组中的第一个元素依次和有序数组作比较
for (; j >= 0 && key < arr[j]; j -= gap) {
// 如果比某个元素小，则交换位置
arr[j + gap] = arr[j]
}
arr[j + gap] = key
}
gap = Math.floor(gap / 2)
}
return arr
}
归并排序
核心算法：
1.先使用递归将数组划分成一个个长度为1的数组
2.将两个有序的数组合并成一个有序的数组，方法是：依次比较左右两个数组中第一个元素的大小，小的元素放到新数组的末尾，并删除该元素
function mergeSort(arr) {
// 将两个有序的数组合并成一个有序的数组
function merge(leftArr, rightArr) {
console.log(leftArr, rightArr);
let newArr = []
while (leftArr.length && rightArr.length) {
// 依次比较左右两个数组中第一个元素的大小，小的元素放到新数组中
if (leftArr[0] > rightArr[0]) {
newArr.push(rightArr.shift())
} else {
newArr.push(leftArr.shift())
}
}
return [...newArr, ...leftArr, ...rightArr]
}
// 数组中只有一个元素，是有序的
if (arr.length === 1) return arr
let mid = Math.floor(arr.length / 2)
// 将数组一分为二
let leftArr = mergeSort(arr.slice(0, mid))
let rightArr = mergeSort(arr.slice(mid))
return merge(leftArr, rightArr)
}
