剑指offer-Python3版(十三)

剑指offer-Python3版(十三)

数字在升序数组中出现的次数

Q:统计一个数字在排序数组中出现的次数

思路

right()的作用就是在升序数组中找到cur的插入位置，有相同的值就插到当前值的右边。位置相减就是所求数字的个数。

class Solution:
    def search(self, nums: [int], target: int) -> int:
        def right(cur):
            """
            right 方法计算的是右边界

            """
            i = 0
            j = len(nums) - 1
            while i <= j:
                mid = (i + j) // 2
                if nums[mid] <= cur:
                    i = mid + 1
                else:
                    j = mid - 1
            return i
        return right(target)-right(target-1)

二叉树的深度

Q:输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

思路

深度优先遍历

只要知道 树的深度=max(左子树的深度,右子树的深度)+1就可以了，其他的事情交给递归去想

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        """
        二叉树的深度 DFS
        :param root:
        :return:
        """
        if not root:
            return 0
        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1

广度优先遍历

也叫层序遍历，利用队列实现。

tmp用来存下一层的节点，tmp每次把一层的节点给queue，res+1，循环跳出的条件就是queue为空。

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        """
        二叉树的深度 BFS 借用队列来做
        :param root:
        :return:
        """
        if not root:
            return 0
        depth_num = 0
        queue = [root]
        while queue:
            tmp = []
            for node in queue:
                if node.left:
                    tmp.append(node.left)
                if node.right:
                    tmp.append(node.right)
            queue = tmp
            depth_num += 1
        return depth_num

平衡二叉树

Q:输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

思路

剪枝orz，第一遍我想到的是层序遍历，没想到剪枝，

节点左右深度差<=1，返回深度；>2，返回-1

当返回-1后，就不是平衡树,剪枝

class Solution:
    def is_balanced(self, root) -> bool:
        def recur(root):
            if not root:
                return 0
            left = recur(root.left)
            if left == -1:
                return -1
            right = recur(root.right)
            if right == -1:
                return -1
            return max(left, right) + 1 if abs(left - right) <= 1 else -1

        return recur(root) != -1