【近日力扣】（递归合集）子集+递归乘法+数值的整数次方

递归合集，当无法思考出调用栈的所有情况时，可以忽略，找出对应递归公式和终止条件即可

子集（中等）

• 思路一：迭代。用二进制依次递增1的规律模拟从集合里取元素的过程，以集合 [1, 2 ,3] 举例，见下表

二进制数	子集
000	[]
001	[1]
010	[2]
011	[1, 2]
100	[3]
101	[1, 3]
110	[2, 3]
111	[1, 2, 3]

• 用位运算模拟该过程

var subsets = function(nums) {
    let ans = [], n = nums.length
    // 二进制数从0开始递增，依次加一
    for (let mask = 0; mask < (1 << n); mask++) {
        let subset = []
        // 取出 mask 里 1 所在位对应的所有元素
        for (let i = 0; i < n; i++) {
            if (mask & (1 << i)) subset.push(nums[i])
        }
        ans.push(subset) // 放入子集
    }
    return ans
};

• 思路二：递归，两种情况，第 i 个元素在子集中时，不在时

var subsets = function(nums) {
    let ans = []
    let subset = []
    let dfs = (cur, nums) => {
    	// 递归到nums末尾时，返回
        if (cur === nums.length) {
            ans.push(subset.slice())
            return ans
        }
        subset.push(nums[cur]) // 有nums[cur]元素的情况
        dfs(cur + 1, nums)
        subset.pop(nums[cur]) // 没有nums[cur]元素的情况
        dfs(cur + 1, nums)
    }
    dfs (0, nums)
    return ans
};

递归乘法（中等）

• 思路：虽说中等题，但是思路不难，也就是把乘法变成加法，比如 20 * 3，就换成 20 + 20 + 20，用递归解决

var multiply = function(A, B) {
    if (A === 0 || B === 0) {
        return 0
    }
    if (A > B) return A + multiply(A, B - 1)
    return B + multiply(A - 1, B)
};

数值的整数次方

• 思路：递归，需要处理计算次数。比如偶次幂，3**4 可换成 9**2，奇次幂，3**5 可换成 3*9**2，减少了百分之五十的计算次数，这样不会栈溢出

var myPow = function(x, n) {
    if (n === 0) return 1
    if (n < 0) {
        return myPow(1 / x, -n)
    }
    return (n % 2 === 0) ? myPow(x * x, n / 2) : x * myPow(x * x, Math.floor(n / 2))
};

如果觉得对你有帮助的话，点个赞呗~

反正发文又不赚钱，交个朋友呗~

如需转载，请注明出处foolBirdd