排序算法

排序（冒泡排序，选择排序，插入排序，归并排序，快速排序，计数排序，基数排序） - VisuAlgo

let minOf2 = numbers => numbers[0] < numbers[1] ? numbers[0] : numbers[1]

可简写为：解构赋值/析构赋值

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

• 控制台报错：从最后一行开始读； at :1:1 的意思是当前的函数 sort([12,5,8,7,9]) 是匿名函数；

at sort (:3:17) 的意思是：匿名函数调用了 sort() ;

at minIndex(:2:11) 的意思是：sort() 调用了 minIndex() ;

minIndex() 发现 min is not defined;

• Math 对象 Math 看起来像 Object 一样是构造函数，实际上 Math 只是一个普通对象，JS 中首字母大写的都是构造函数，只有 Math 例外。

// let minOf2 = numbers=> 
//   numbers[0]<numbers[1] ? numbers[0] : numbers[1]

let minOf2 = ([a,b]) => a < b ? a : b ;
let minOf3 = ([a,b,c])=>{
  return minOf2[a,minOf2([b,c])]
}
let minOf4 = ([a,b,c,d])=>{
  return minOf2([a,minOf3([b,c,d])])
}
// 求最小值
let min = (numbers)=>{
  if(numbers.length>2){return min([numbers[0],min(numbers.slice(1))])
  }else{
    return Math.min.apply(null,numbers)
  }
}

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

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

• 计数排序： $n^2$

let sort = (numbers)=>{
  if(numbers.length >2){
    let index = numbers.indexOf(min(numbers))
    console.log(`index:${index}`)  // console.log() 调试
    let minNum = numbers[index]
    numbers.splice(index,1)
    return [minNum].concat(sort(numbers))
  }else{
    return sort2(numbers)
  //return numbers[0]<numbers[1]?numbers:numbers.reverse()
  }
}
console.log(sort([33,24,5,2,3,52,7]))

• 快速排序: n*$log_2$n

let quickSort = arr=>{
    if(arr.length<=1){return arr}
    else{
      console.log(`-------`)
      let pivotIndex = Math.floor(arr.length/2)
      console.log(`pivotIndex:${pivotIndex}`)
      let pivot = arr[pivotIndex]
      console.log(`pivot:${pivot}`)
      let left = []
      let right = []
      arr.splice(pivotIndex,1)
      console.log(`arr:${arr}`)
      for(i=0;i<arr.length;i++){
        if(arr[i]<pivot){
          left.push(arr[i])
          console.log(`left:${left}`)
        }else{
          right.push(arr[i])
          console.log(`right:${right}`)
        }
      }
      return quickSort(left).concat([pivot],quickSort(right))
     }
  }

• 计数排序：n+max

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]}
  }
  for(let j=0; j<=max; j++){ // 遍历哈希表
    if(j in hashTable){
      for(let i = 0; i<hashTable[j]; i++){ //数组中有重复的数
        result.push(j)
      }
    }
  }
  return result
}

• 归并排序：n*$log_2$n

let mergeSort = arr=>{
    let k = arr.length
    if(k===1){return arr}
    let left = arr.slice(0,Math.floor(k/2))
    let right = arr.slice(Math.floor(k/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))
}