• python code practice(四):树、图


    1、平衡二叉树

    给定一个二叉树,判断它是否是高度平衡的二叉树。

    本题中,一棵高度平衡二叉树定义为:

    一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

    示例 1:

    给定二叉树 [3,9,20,null,null,15,7]

      3
     / 
    9  20
       /   
    15     7
    返回 true 。

    示例 2:

    给定二叉树 [1,2,2,3,3,null,null,4,4]

           1
         /   
        2     2
       /   
      3    3
     /   
    4    4
    返回 false 。

    方法1:此方法容易想到,但会产生大量重复计算,时间复杂度较高。

    思路是构造一个获取当前节点最大深度的方法 depth(root) ,通过比较此子树的左右子树的最大高度差abs(depth(root.left) - depth(root.right)),来判断此子树是否是二叉平衡树。若树的所有子树都平衡时,此树才平衡。总之,我们只要求左右子树相差的高度是否超过 1,就可以了!

    算法流程
    isBalanced(root) :判断树 root 是否平衡

    特例处理: 若树根节点 root 为空,则直接返回 truetrue ;
    返回值

    所有子树都需要满足平衡树性质,因此以下三者使用与逻辑 &&&& 连接;
    abs(self.depth(root.left) - self.depth(root.right)) <= 1 :判断 当前子树 是否是平衡树;
    self.isBalanced(root.left) : 先序遍历递归,判断 当前子树的左子树 是否是平衡树;
    self.isBalanced(root.right) : 先序遍历递归,判断 当前子树的右子树 是否是平衡树;
    depth(root) : 计算树 root 的最大高度

    终止条件: 当 root 为空,即越过叶子节点,则返回高度 00 ;
    返回值: 返回左 / 右子树的最大高度加 11 。
    复杂度分析
    时间复杂度 O(Nlog2N): 最差情况下, isBalanced(root) 遍历树所有节点,占用 O(N) ;判断每个节点的最大高度 depth(root) 需要遍历 各子树的所有节点 ,子树的节点数的复杂度为 
    空间复杂度 O(N): 最差情况下(树退化为链表时),系统递归需要使用 O(N) 的栈空间。

    class Solution:
        def isBalanced(self, root: TreeNode) -> bool:
            if not root: 
                return True
            return abs(self.depth(root.left) - self.depth(root.right)) <= 1 and 
                self.isBalanced(root.left) and self.isBalanced(root.right)
    
        def depth(self, root):
            if not root: 
                return 0
            return max(self.depth(root.left), self.depth(root.right)) + 1

    方法2:

    从底至顶(提前阻断)
    此方法为本题的最优解法,但“从底至顶”的思路不易第一时间想到

    思路是对二叉树做先序遍历,从底至顶返回子树最大高度,若判定某子树不是平衡树则 “剪枝” ,直接向上返回。

    算法流程
    recur(root):

    递归返回值
    当节点root 左 / 右子树的高度差 < 2 :则返回以节点root为根节点的子树的最大高度,即节点 root 的左右子树中最大高度加 1 ( max(left, right) + 1 );
    当节点root 左 / 右子树的高度差≥2 :则返回 -1 ,代表 此子树不是平衡树 。
    递归终止条件
    当越过叶子节点时,返回高度 00 ;
    当左(右)子树高度 left== -1 时,代表此子树的 左(右)子树 不是平衡树,因此直接返回 −1 ;
    isBalanced(root) :

    返回值: 若 recur(root) != 1 ,则说明此树平衡,返回true ; 否则返回false 。
    复杂度分析
    时间复杂度 O(N): N 为树的节点数;最差情况下,需要递归遍历树的所有节点。
    空间复杂度 O(N): 最差情况下(树退化为链表时),系统递归需要使用 O(N) 的栈空间。

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

    2.找树左下角的值

    给定一个二叉树,在树的最后一行找到最左边的值。

    示例 1:

    输入:

    2
    /
    1 3

    输出:
    1

    示例 2:

    输入:

        1
       / 
      2   3
     /    / 
    4   5   6
         /
        7

    输出:

    7

    注意: 您可以假设树(即给定的根节点)不为 NULL。

    方法1:从右到左的层序遍历,不需记录中间值(除了队列)。

    一般的层序遍历是每层从左到右,遍历到最后的元素就是右下角元素。
    如果反过来,每层从右到左进行层序遍历,最后一个就是左下角元素,直接输出即可,不需要记录深度。

    class Solution:
        def findBottomLeftValue(self, root: TreeNode) -> int:
            if not root:
                return -1
            queue = collections.deque()
            queue.append(root)
            while queue:
                cur = queue.popleft()
                if cur.right:   # 先右
                    queue.append(cur.right)
                if cur.left:    # 后左
                    queue.append(cur.left)
            return cur.val

    方法2:广度优先遍历保存每层第一个节点。

    class Solution:
        def findBottomLeftValue(self, root: TreeNode) -> int:
            last  = None
            stack = [root]
            while stack:
                last = stack[0].val
                for i in range(len(stack)):
                    n = stack.pop(0)
                    if n.left:
                        stack.append(n.left)
                    if n.right:
                        stack.append(n.right)
            return last

    方法3:

    准备一个字典,key为层深,value为该层节点值
    中序遍历时,记录层深
    取最深层第一个节点值即可

    from collections import defaultdict
    class Solution:
        def findBottomLeftValue(self, root: TreeNode) -> int:
            height_dict = defaultdict(list)
            def helper(node, now):
                if not node:
                    return now
                left = helper(node.left, now+1)
                height_dict[now].append(node.val)
                right = helper(node.right, now+1)
            helper(root, 0)
            return height_dict[max(height_dict.keys())][0]

    方法:另一个写法

    逐层遍历,先右后左,最后剩下底层最左。

    class Solution:
        def findBottomLeftValue(self, root: TreeNode) -> int:
            next_level = [root]
            while next_level:
                node = next_level.pop(0)
                if node.right: next_level.append(node.right)
                if node.left: next_level.append(node.left)
            return node.val
  • 相关阅读:
    单例模式 MonoState
    适配器模式+AutoFac
    复合模式 泛型检查
    复合模式
    OpenDaylight实验
    Open vSwitch
    Mininet入门实战
    Python基础语句学习
    修改用户密码登录期限
    springboot maven自定义jar包包名, 增加环境、时间版本号信息
  • 原文地址:https://www.cnblogs.com/ariel-dreamland/p/12641638.html
Copyright © 2020-2023  润新知