目前只学了七八种，不敢多看，忘得快也看不懂，会痛苦加倍，后续会完善这个博客的。
冒泡排序
//冒泡排序 相邻的两位排序 每一趟排序都把未排序的数字中最大的放到最后
function maoPao(arr){
for(let i = 0;i < arr.length;i++){//外层循环的是趟数
for(let j = 0;j < arr.length-i;j++){//内层循环的是每一趟相邻的两个数，每次循环结束的地方都是总长-趟数，因为已经走了几趟就有几个数字被排序好了
if(arr[j]>arr[j+1]){
let tmp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = tmp
}
}
}
return arr
}
简单选择排序
//简单选择排序 每一趟都找没有排序的数字里最小 放在没排好的数前面
function xuanZe(arr){
let minIndex = null
for(let i = 0;i < arr.length-1;i++){//外层循环的是趟数
minIndex = i
for(let j = i+1;j < arr.length;j++){//内层在找最小数的下标
if(arr[j]<arr[minIndex]){
minIndex = j
}
}
//交换最小数
let tmp = arr[minIndex]
arr[minIndex] = arr[i]
arr[i] = tmp
}
return arr
}
插入排序
//插入排序 每一趟选一个数字跟前面已经排好的数字进行比较
function chaRu(arr){
for(let i = 1;i < arr.length;i++){
let preIndex = i-1
let current = arr[i]
while(preIndex >= 0 && current < arr[preIndex]){
//如果上一个值大于当前值，要换变量
//这里不直接处理current是为了保留它的值,使用preIndex是为了改变它和它旁边的值
arr[preIndex+1] = arr[preIndex]
preIndex--
}
arr[preIndex+1] = current
}
return arr
}
希尔排序
//希尔排序 每一趟都根据一定的的间距选定几个数，对这几个数在它们各自的位置排序，一趟一趟下来间距越来越小
function xiEr(arr){
for(let i = Math.floor((arr.length-1)/2);i > 0;i=Math.floor(i/2)){//外层循环遍历 i是一趟的间距，间距会对半减小
for(let j = i;j < arr.length;j++){//内层遍历的是在这个间距范围的两个数的大小
while(arr[j-i]>arr[j]){
//交换两个数
let tmp = arr[j-i]
arr[j-i] = arr[j]
arr[j] = tmp
//j往前走，因为结束这次循环的时候j会加一，所以相当于j根据和它对比的那个数往后走
j = j-i//这里还涉及到 如果没有发生交换的话就正常j+1 发生交换的话j直接推到和它比较的那个数的位置，然后再加一
///j-i是个负数的话，arr[j-i]<arr[j]一定是false 所以j还是会加一 往后面找需要交换的两个数或者超出范围进行下一个步长
}
}
}
return arr
}
归并排序
//归并排序 把数组分组，每组进行排序，再两组两组合并进行排序，最后合成最大的完整的数组，这里用从大到小的分割数组进行递归
function guiBing(arr){//把传入的数组分成两个
// console.log(arr)
//这里对传入的数组进行长度判断，是因为当数组被分割到只剩一个的时候就要返回这个数组了
if(arr.length < 2){
return arr
}
let middle = Math.floor(arr.length/2),
left = arr.slice(0,middle),
right = arr.slice(middle)//这里相当于把数组分成两个了
return guiBingRecur(guiBing(left),guiBing(right))
}
//对传入的两个数组进行合并并排序
function guiBingRecur(left,right){
let ans = []
while(left.length && right.length){//这里要注意判断的是数组的长度，如果只判断数组的话，就算数组是空的也会返回true
if(left[0] < right[0]){
ans.push(left.shift())
}else{
ans.push(right.shift())
}
}
//代码到这里是因为两个数组中有一个已经空了，另一个里面还有东西
while(left.length){
ans.push(left.shift())
}
while(right.length){
ans.push(right.shift())
}
return ans
}
快速排序
//快速排序 手排和代码出来的过程看上去咋这么不一样 代码排的核心是 每一趟都选出来一个数字，遍历其他的数字，比它大放右边，小的放左边，而且要递归
function kuaiPai(arr){
if(arr.length <= 1) return arr
let current = arr.shift()
let left = []
let right = []
for(let i = 0;i < arr.length;i++){
arr[i] > current ? right.push(arr[i]) : left.push(arr[i])
}
//这里要合并分开的数组并且返回出去
return kuaiPai(left).concat(current,kuaiPai(right))
}
堆排序
//堆排序 分为大顶堆和小顶堆 都是完全二叉树 分别是父节点比子节点大、小
//完全二叉树的特点：下标i的父节点：Math.floor((i-1)/2) 下标i的左子节点：2i+1 下标i的右子节点：2i+2
let duiPai = {
arr:[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48],
length:15,
makeMax:function(arr){
for(let i = Math.floor(arr.length/2);i >= 0;i--){
this.recur(arr,i)
}
},//建立大顶堆
recur:function(arr,i){
let left = 2*i+1,
right = 2*i+2,
largest = i
//判断当前节点和它的左右节点的大小
if(left < this.length && arr[largest] < arr[left]) largest = left 这里left<this.length为啥要跟this.length判断，为啥不跟数组的长度判断
if(right < this.length && arr[largest] < arr[right]) largest = right 我真的不理解 什么鬼
//判断最大节点是不是传入的节点i
if(largest != i){
this.swap(arr,i,largest)
//递归
this.recur(arr,largest)
}
},//传入节点i,对i和它的左右节点比较，并递归到树最底层
swap:function(arr,i,j){
let tmp = arr[i]
arr[i] = arr[j]
arr[j] = tmp
},//交换下标i,j的数字
heapSort:function(arr){
this.makeMax(arr)//首先创建大顶堆
//再对每一个节点进行调整
for(let i = arr.length-1;i>0;i--){
this.swap(arr,i,0)
// console.log(`交换节点之后${arr}`)
this.length--
this.recur(arr,0)
// console.log(`排序完之后${arr}`)
}
return arr
}
}
计数排序
//计数排序 它要求数组是一个小范围的整数 所以传值的时候同时要传进去数组的最大值数组长度
function countSort(arr,maxValue){
//创建计数数组
let countArr = new Array(maxValue+1),//计数数组长度应该是最大值加一 因为下标从零开始 计数数组的下标对应的是传入的arr的值
sortedIndex = 0//根据计数数组对arr重新排序的时候当前值是几代表排的arr下标是几的数
//循环计数
for(let i = 0;i < arr.length;i++){
if(!countArr[arr[i]]){
countArr[arr[i]] = 1
}else{
countArr[arr[i]]++
}
}
//根据计数数组处理arr
for(let j = 0;j < maxValue+1;j++){
//如果当前下标的值不是0 说明要排序了
while(countArr[j]!=0){
arr[sortedIndex++] = j
countArr[j]--
}
}
return arr
}
// console.log(countSort([3,3,5,2,1,0,0,4,3],5))
