【算法与数据结构】排序

一、找出两数的最小值

let minOf2 = (numbers) => {
	if(numbers[0] < numbers[1]){
    	return numbers[0] //必须加return
    }else{
    	return numbers[1]
    }
}

//优化后
let minOf2 = numbers => numbers[0] < numbers[1] ? numbers[0] : numbers[1] 
//{}可以省略，numbers的()也可以省略，因为只有一个参数

还可以优化

let minOf2 = ([a,b]) => a < b ? a : b
//()不能省略，这种写法叫做析构赋值，将参数的结构写明

调用

• minOf2([1,2]) 小白调用法，不推荐
• minOf2([null,[1,2]]) 大师调用法，推荐

还可以直接用API

• Math.min(1,2)
• Math.min.call(null,1,2)
• Math.min.apply(null,[1,2])
• Math看起来是构造函数，但是它是普通函数，除此以外，首字母大写的函数都是构造函数

二、找到三个数字中的最小值

let minOf3 = ([a,b,c]) => {
	return minOf2([minOf2[a,b],c]) //先求前2个数字的最小值
]

三、求任何长度数组中元素的最小值

使用递归

let min = (numbers) => {
	if(numbers.length > 2){
		return min(
    		[numbers[0],min(numbers.slice(1))]
    	)
    }else{
    	return Math.min.apply(null,numbers) //apply将numbers参数展开传给Math.min，min不接受数组
    }
}
//递归

  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 ? [a,b] : [b,a] //析构赋值，()不能省略

长度为3的数组排序，调用了min和sort2

let sort3 = (numbers) => {
	let index = minIndex(numbers)
    let min = numbers[index]
    numbers.splice(index,1) //从numbers中删除最小的数字
    return [min].concat(sort2(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) => {
	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] + sort([12,8,7,9])
= [5] + ([7] + sort([12,8,9]))
= [5] + ([7] + ([8] + sort([12,9])))
= [5] + ([7] + ([8] + ([9,12])))
= [5] + ([7] + ([8,9,12]))
= [5] + ([7,8,9,12])
= [5,7,8,9,12]