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

递归需要return

function fn(n){
    console.log(n)
    if(n===0){
    	// debugger;
        return 0
    }
    else{
    	// debugger;
        fn(n-1)+1 
    }
}
fn(3)

不return的话，压在调用栈中的函数无法一层一层往上给值

用递归对一个不定长数组求最小值

递归就是先递进再回归
只有不断地调用自身函数才叫递归
递进到一个终点才开始执行之前待执行的

// 写法1
function min(...arr){// 接数字，...转成数组
	console.log(arr.length);
    if(arr.length===2){
    	let minNumber=Math.min.apply(null,arr);
    	return minNumber
    }else{
    	return min(arr[0],min(...arr.slice(1)));
        //注意 这里必须return出去
        //这里return出去才能在递进到底的时候，让之前所有处在递进过程中待执行的函数顺利执行
	}
}
min(1,2,3,4,5,6,7)

// 写法2
function min(arr){// 直接传入数组
    if(arr.length===2){
    	let minNumber=Math.min.apply(null,arr);
    	return minNumber
    }else{
    	return min([arr[0],min(arr.slice(1))]);
	}
}
min([1,2,3,4,5,6,7])

用递归写sort 结果由小到大(选择排序法)

function sort2([a,b]){ // 这种写法明确了你需要传递一个拥有2个元素的数组
   return  a>b?[b,a]:[a,b];
}
function minIndex(arr){
	return arr.indexOf(Math.min.apply(null,arr))
}
function sort3([a,b,c]){
	let arr=[a,b,c];
    let i = minIndex([a,b,c])
    let minResult=arr.splice(i,1)
    let result=minResult.concat(sort2(arr))
    return result
}
sort3([3,2,1])
function sort4([a,b,c,d]){
	let arr=[a,b,c,d];
    let i = minIndex([a,b,c,d])
    let minResult=arr.splice(i,1)
    let result=minResult.concat(sort3(arr))
    return result
}
// 由上述过程捕捉到了规律
function minIndex(arr){
	return arr.indexOf(Math.min.apply(null,arr))
}
function sort2([a,b]){ // 这种写法明确了你需要传递一个拥有2个元素的数组
   return  a>b?[b,a]:[a,b];
}
function sort(arr){
	if(arr.length===2){
		return  sort2(arr)
	}else{
      let i = minIndex(arr)
      let minResult=arr.splice(i,1)
      let result=minResult.concat(sort(arr))
      return result
	}    
}
sort([5,2,1,3])