两个数找到较小的那个

代码

  let minOf2 =(numbers) =>{
      if(numbers[1]>numbers[0]){
          return number[0]
      }else{
          return number[1]
      }
  }

优化代码

let minOf2 =numbers =>{
    numbers[1] >number[0] ? number[0]:number[1]
}

再优化代码

析构赋值

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

调用

** minOf([1,2]) //1 这是小白调用法**

minOf.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])

三个数找出最小的那个

代码

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

推理

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

找出最小的那个

递归代码

没有判断是否小于2

let min =(numbers) =>{
    retrun min(
    [numbers[0],  min(numbers.slice(1))]
    
    )
}

判断是否小于2

let min =(numbers) =>{
    if(numbers.length >2){
        return min(
            [numbers[0],min(numbers.slice(1))]
         )
        }else{
            return Math.min.apply(null,numbers)
        }
    
}

解析

 min([2,4,3,1])
= min([2,    min([4,3,1]) ])
=min([ 2,    min([4,  min ([3,1]) ] )  ])
=min 2   ,min 4  ,Math.min.apply (null , [3, 1])
=min 2,(min 4, 1)
=min 2 ,1
= 1

长度为2的数组排序

代码

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

优化代码

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

长度为3的数组排序

let sort3 =(numbers) =>{
    let index =minIndex(numbers)//拿到最小数的下标
    let min =numbers[index]
    //最小值
    number.splice(index,1)
    //从numbers 里删掉最小值
    
    return [min].concat(sort2(numbers)
}


let minIndex =(numbers) =>
numbers.indexOf(min(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）=>{
    let index =minIndex(numbers)
    //拿到最小值的下标
     let  min =numbers[index] //最小值
     numbers.splice(index,1)
     return [min].concat(sort(numbers))
}

解决方法：加if-else

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[1] >number[0] ?numbers :numbers.reverse()
  }
}