所有的递归都可以改成循环

长度为2的排序

let sort2 =([a,b])=>{
if (a<b){
return[a,b]
}else{
return[b,a]
}
 }

优化代码

let sort2 = ([a,b])=>
a<b ? [a,b]:[b,a]

长度为3的数组排序

let sort3 = ([a,b,c])=>{
return[min([a,b,c]),  sort2([???])]
}

min是找出最小的值，第二个数组无法选择出

改进代码

let sort3 = (numbers) => {
let index = minIndex(numbers)//首先拿到最小值的下标index，minindex表示最小值的下标
let min = number[index]//min是最小值，下标为index的数字
numbers.splice(index,1)//从numbers删除1个最小值的
return[min].concat(sort2(numbers)//这是两个数组相加，第一个数组就是最小的数组，第二个数组就是剩余两个数值的数组排序后的
}

数组为4 个的排序

代码

let sort4 = (numbers)=>{
let index = minIndex(numbers)
let min = numbers[index]
numbers.splice(index,1)
return[min].concat(sort3(numbers))
}

任意长度的数组排序

let sort = (numbers) => {
if(numbers.length > 2){

let index = minIndex(numbers)
let min = numbers[index]
numbers.splice(index,1)
return[min].concat(sort(numbers))
}else{
return numbers[0]<numbers[1] ? numbers:
       numbers.reverse()
       }
      }

四种排序

选择排序 快速排序 归并排序 计数排序

选择排序

let arr = [2, 5, 4, 1, 3, 6, 8, 7]
let minIndex = (numbers) => {
  let index = 0
  for (let i = 1; i < numbers.length; i++) {
    if (numbers[index] > numbers[i]) {
      index = i
    }
  }
  return index//得到了最小值的下标
}
let swap = (numbers, i, j) => {
  let temp = numbers[i]
  numbers[i] = numbers[j]
  numbers[j] = temp
}
let sort = (numbers) => {
  for (let i = 0; i < numbers.length - 1; i++) {
    let index = minIndex(numbers.slice(i)) + i
    if (index !== i) {
      swap(numbers, index, i)
    }
  }
  return numbers
}
console.log(sort.call(null, arr))

快速排序

let arr = [3, 6, 8, 4, 7, 1, 5]
let quickSort = (arr) => {
if (arr.length <= 1) { return arr }
let baseIndex = Math.floor(arr.length / 2)
let base = arr.splice(baseIndex, 1)[0]
console.log(base)
let left = []
let right = []
for (let i = 0; i < arr.length; i++) {
  arr[i] > base ? right.push(arr[i]) : left.push(arr[i])
}
return quickSort(left).concat([base], quickSort(right))
}
console.log(quickSort(arr))

###　归并排序

let arr = [3, 1, 6, 7, 4, 5, 10]
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))
}


let mergeSort = (arr) => {
if (arr.length === 1) { return arr }
let left = arr.slice(0, Math.floor(arr.length / 2))
let right = arr.slice(Math.floor(arr.length / 2))
return merge(mergeSort(left), mergeSort(right))
}
console.log(mergeSort.call(null, arr))

计数排序

let a = [1, 4, 6, 4, 3, 2, 7, 4, 100]
let countSort = (arr) => {
let hashTable = {}
let max = 0
let result = []
for (let i = 1; 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(max)
for (let j = 0; j <= max; j++) {
  for (let i = 0; i < hashTable[j]; i++) {
    if (j in hashTable) {
      result.push(j)
    }
  }
}
return result
}
console.log(countSort.call(null, a))

下面的仅供参考

let minIndex = (numbers) =>
let index = 0
for (let i=1;i<numbers.length;i++){
if (numbers[i]<numbers[index]){
index = i
}
}
return index
}
//minIndex是最小数值的下标 

总结

所有递归都能改成循环 学会看控制台，学会log

快速排序（quick sort）

pivotIndex//基准索引
math.floor//地板的意思，就是三点几的地板就是三这个整数，往下走最靠近的一个整数，还有天花板
let quickSort = arr =>{ //快速排序就是等于一个数组
if (arr.length<=1){return arr;}//如果数组的长度小于等于1，就直接返回这个数组，没必要排序
let pivotIndex = Math.floor(arr.length/2);//数组长度的一半，中间数
let pivot = arr.splice(pivotIndex,1)[0];//把这个基准数单独提出来一个数，因为这个提出来的数组只有一项，所以【0】表示的是这个数组的第1个。就是为了把这个数组变成一个数。
let left = [];//左边的数组等于空
let right = [];//右边的数组等于空
for(let i = 0; i< arr.length;i++){//让i等于0，遍历删掉基准的array
if (arr[i]<pivot){lef.push(arr[i])
}else{right.push(arr[i])}
}
return quickSort(left).concat(
[pivot],quickSort(right))
}
 

归并排序（merge sort）

技术排序

思路 用一个哈希表做记录，发现数字N就记N:1,假设N：m，那么N需要打印m次； 画图演示

let countSort = arr =>{
let hashTable = {},max = 0, result = [] //结果是一个数组，暂时为空
for (let i=0;i<arr.length;i++){//遍历数组，从下标0到数组长度减一
if(!(arr[i] in hashTable)){
hashTable[arr[i]] = 1
}else hashTable[arr[i]]+=1
}if (arr[i] > max){max = arr[i]}
}
for (let j = 0;j <= max;j++){//遍历哈希表
if(j in hashTable){
result.push(j)
}
}
return.result
}//目前代码有bug