《LeetCode零基础指南》(第九讲) 简单递归

172. 阶乘后的零 - 力扣（LeetCode） (leetcode-cn.com)

思路：计算后面零的个数，因为组成一个零，需要偶数和五两个数来构成，所以相对来说五这个数就比较特殊，只有五的倍数才有零的出现。

解法一：用while循环查找，n除以5的倍数，就可以判断出零的个数。时间复杂度是O（logn），空间复杂度是O(1)。

class Solution:
    def trailingZeroes(self, n: int) -> int:
        t=0
        while(n!=0):
            t+=n//5
            n=n//5
        return t

解法二：用递归表达式，进行递归叠加。

class Solution:
    def trailingZeroes(self, n: int) -> int:
        if n<5:
            return 0
        else:
            return (n//5)+self.trailingZeroes(n//5)

1342. 将数字变成 0 的操作次数 - 力扣（LeetCode） (leetcode-cn.com)

思路：递归思想，知道数字为0，停止操作，否则不断进行操作。

解法一：利用while循环进行求解，当n为0的时候结束判断，时间复杂度是O(logn),没有创建新的数组，所以空间复杂度是O(1)。

class Solution:
    def numberOfSteps(self, num: int) -> int:
        count=0
        while num:
            if (num%2==0):
                num=num//2
            else:
                num=num-1
            count+=1
        return count

解法二：可以利用判断，按位运算的判断和1相比，因为当n为偶数的时候，末尾是0结尾，当n为奇数，末尾是1结尾的，所以可以通过‘1’的数目来判断操作的次数。

class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root: return 0
        level = 0
        node = root.left
        while node:  # 这里获得层数
            level += 1
            node = node.left
        l = 2**level
        r = 2**(level+1)-1
        def check(mid,node):
            path = bin(mid)[3:]
            for i in path:
                if i=='1':
                    node=node.right
                else:
                    node=node.left
            if node:
                return True
            else:
                return False
        while l < r:
            mid =(r+l)//2+1  # 中位
            node = root
            if check(mid,node):
                l=mid
            else:
                r=mid-1
        return r

222. 完全二叉树的节点个数 - 力扣（LeetCode） (leetcode-cn.com)

思路：递归，先确定左边结点数目，然后在确定右边结点的数目，加上第一个结点，用递归可以解决问题。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: TreeNode) -> int:
        if not root:
            return 0
        return 1 + self.countNodes(root.left) + self.countNodes(root.right)

LCP 44. 开幕式焰火 - 力扣（LeetCode） (leetcode-cn.com)

思路：递归

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def numColor(self, root: TreeNode) -> int:
        res_set = set()
        stack = [root,]
        while stack:
            node = stack.pop()
            res_set.add(node.val)
​
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
​
        return len(res_set)

397. 整数替换 - 力扣（LeetCode） (leetcode-cn.com)

思想：递归

class Solution:
    def integerReplacement(self, n: int) -> int:
        if n==1:
            return 0
        if n%2==0:
            return 1+self.integerReplacement(n//2)
        return 2+min(self.integerReplacement(n//2),self.integerReplacement(n//2+1))