找出最小的数

两个数找出较小的那个（minOf2的实现）

let 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]
undefined

再优化代码：这种写法叫做析构赋值

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

调用

• minOf2([1,2]) // 1 这是小白调用法

• minOf2.call(null, [1,2]) // 这是高手调用法

现成的API

JS内置了Math.min

• Math.min(1,2) // 1

• Math.min.call(null,1,2)

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

四个数中找出最小的那个（minOf4 的实现）

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

• 任意长度数组求最小值，都可以通过minOf2来实现

找出最小的那个数

代码

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] //这里的[a,b] 不等于 上面的数组[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([???])]
}

改进代码

let sort3 = (numbers) =>{
    let index = minIndex(numbers)
    let min = numbers[index]
    numbers.splice(index, 1)
    // 从numbers 里删掉 min
    return [min].concat(sort2(numbers))
}

长度为4的数组排序

代码

let sort4 = (numbers) =>{
    let index = minIndex(numbers)
    let min = number[index]
    numbers.splice(index, 1)
    // 从numbers 里删掉 min
    return [min].concat(sort3(numbers))
}

任意长度的数组排序

let minIndex = (numbers) =>
    numbers.indexOf(min(numbers))
let min = (numbers) =>{
    if(numbers.length > 2) {
        return min(
            [numbers[0], min(numbers.slice(1))]
        )
    }else{
        return Math.min.apply(null, 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()
    }
}

例题：将[12,5,8,7,9]排序

let minIndex = (numbers) =>
    numbers.indexOf(min(numbers))
let min = (numbers) =>{
    if(numbers.length > 2) {
        return min(
            [numbers[0], min(numbers.slice(1))]
        )
    }else{
        return Math.min.apply(null, 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()
    }
}
sort([12,5,8,7,9) // [5,7,8,9,12]