两数中找出较小的那个

代码

var minOf2 = (numbers)=>{
 if(numbers[0] < numbers[1]){
   return numbers[0]
 }else{
   return numbers[1]
 }
}

优化代码

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

继续优化（解构赋值）

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

调用：

1. minOf2([1,2])
2. minOf2(null,[1,2])//推荐这种写法

使用现成的API

JS 内置了 Math.min
调用方法：

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

关于Math

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

三数中找出最小的那个

let minOf3 = ([a,b,c]) => {
    return minOf2([minOf2[a,b],c])
}

或者

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)
  }
}

递归：

特点

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

理解

• 可以用代入法快速理解递归
• 可以用调用栈快速理解递归

长度为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 = (numbers) => {
    let index = minIndex(numbers)
  let min = numbers[index]
  numbers.splice(index,1)
  return [min].concat(sort2(numbers))
}

minIndex

let minIndex = (numbers) => numbers.indexOf(min(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()
  }
}

思路：

• 找到最小数的索引
• 索引对应的值
• 删除最小值
• 对剩下的部分重复前面步骤

  选择排序的循环写法（时间复杂度n^2）

  将 minIndex 用循环写

  let minIndex = (numbers) => {
    let index = 0
  for(let i = 1; i<numbers.length; i++){
      if(numbers[i]<numbers[index]){
        index = i
    }
  }
  return index
  }

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

把 sort 用循环写

思路：
每次在数组中找到最小的数放在前面，然后对后面的数做重复的事情

比如：
[3,5,2,1]
先找1，然后把1跟3换位置 => [1] + [5,2,3]
然后在 [5,2,3] 中找最小数 2 ，然后跟5换位置 => [1,2] + [5,3]
然后在 [5,3] 中找最小数 3，然后跟5 换位置 => [1,2,3] + [5]

let sort = (numbers) => {
    for(let i = 0; i < numbers.length; i++){
      let index = minIndex(numbers.slice(i)) + i
    if(index !== i){
        swap(numbers, index, i)//交换index，i 对应值的位置
    }
  }
  return numbers
}

let swap = (array, i, j) => {
    let temp = array[i]
  array[i] = array[j]
  array[j] = temp
}