从最简单的开始

两个数找出较小的那个

  1. let minOf2 = (numbers) => {
  2.   if(numbers[0] < numbers[1]){
  3.     return numbers[0]
  4.   }else{
  5.     return numbers[1]
  6.   }
  7. }

优化

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

再优化

  1. let minOf2 = ([a,b]) => a < b ? a : b
  2. //这种方法叫做析构赋值

写完代码时刻想着优化
调用

  1. minOf2([1,2]) //不推荐
  2. minOf2.call(null,[1,2]) //推荐，高手用法

JS内置API：Math.min

Math.min(1,2) //1 Math.call(null,1,2) Math.apply(null,[1,2])

关于Math

看起来Math像Object一样是构造函数 实际上Math只是一个普通对象 这是唯一的特例：首字母大写是构造函数

三个数找出最小的那个

举一反三

  1. let minOf3 = ([a,b,c]) => {
  2.   return minO2([minO2([a,b]), c])
  3. }
  4. 或者
  5. let minOf3 = ([a,b,c]) => {
  6.   return minOf2([a, minO2([b,c])])
  7. }

推理

  1. let minOf4 = ([a,b,c,d]) => {
  2.   return minOf2([a, minOf3([a,b,c])])
  3. }

推广
任意长度数组求最小值

找出最小的那个

  1. let min = (numbers) => {
  2.   return min([numbers[0], min(numbers.slice(1))])
  3. }
  4. //这样会死循环
  6. let min = (numbers) => {
  7.   if(numbers.length > 2){
  8.     return min([numbers[0], min(numbers.slice(1))])
  9.   }else{
  10.     return Math.min.apply(null,numbers)
  11.   }
  12. }

这就是递归

  • 特点

函数不停调用自己，每次调用的参数略有不同
当满足某个简单条件时，则实现一个简单的调用
最终算出结果

  • 理解

可以用带入法块速理解递归
可以用调用栈快速理解递归

排序算法

将整数数组从小到大排序

  • 思路

用递归或循环实现

递归思路

选择排序

长度为2的数组排序

  1. let sort2 = ([a,b]) => {
  2.   if(a < b){
  3.     return [a,b]
  4.   }else{
  5.     return [b,a]
  6.   }
  7. }

优化

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

长度为3的数组排序

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

我们发现无法将最小值从数组里删掉
改进代码

  1. let sort3 = (numbers) => {
  2.   let index = minIndex(numbers)
  3.   let min = numbers[index]
  4.   numbers.splice(index,1)
  5.   //从numbers里删掉min
  6.   return [min].concat(sort2(numbers))
  7. }
  8. let minIndex = (numbers) => numbers.indexOf(min(numbers))

任意长度的数组排序

  1. let sort = (numbers) => {
  2.   if(numbers.length > 2){
  3.     let index = minIndex(numbers)
  4.     let min = numbers[index]
  5.     numbers.splice(index,1)
  6.     return [min].concat(sort(numbers))
  7.   }else{
  8.     return numbers[0]<numbers[1] ? numbers : numbers.reverse()
  9.   }
  10. sort([12,5,8,7,9])//[5,7,8,9,12]

代码会错
用console.log调试

总结

求最小值

  • 2个数
  • 3个数
  • N个数

排序

  • 2个数
  • 3个数
  • N个数

学到知识

  • 数组
  • 递归