zoukankan      html  css  js  c++  java
  • 树(3)-----栈(迭代)

    1、求树的所有路径和:

    class Solution_iterative:
        def hasPathSum(self, root, target):
            stack = [(root, 0)]
            while stack:
                node, path = stack.pop()
                if node:
                    if node.left is None and node.right is None and path + node.val == target:
                        return True
                    stack.extend([(node.left, path + node.val), (node.right, path + node.val)])
            return False

    2、交换左右子树

    def invertTree(self, root):
        stack = [root]
        while stack:
            node = stack.pop()
            if node:
                node.left, node.right = node.right, node.left
                stack += node.left, node.right
        return root

     3、求树的每层平均值

    def BFS(root):
           if not root:
                return 0
            prev,res=[root],[]
            while prev:
                 cur=[]
                #给结果添加当前层数prev的平均值,prev为当前所有的值
                val=sum([node.val for node in prev])/float(len(prev))
                res.append(val)
                #该循环主要是cur添加prev所有的左右子树,即cur为下一层所有的值
                while prev:
                    node=prev.pop()
                    if node.left:
                        cur.append(node.left)
                    if node.right:
                        cur.append(node.right)
                #将当前层数变为下一层
                prev=cur        
            return res

    4、二叉树的层次遍历

        def levelOrder(self, root):
            """
            :type root: TreeNode
            :rtype: List[List[int]]
            """
            res=[]
            if not root:
                return []
            prev=[root]
            while prev:           
                temp=[node.val for node in prev]
                res.append(temp)
                cur=[]
                while prev:
                    node=prev.pop(False)  
                    if node.left:
                        cur.append(node.left)                 
                    if node.right:
                        cur.append(node.right)
                prev=cur
            return res

    5、二叉树的第二小节点

        def findSecondMinimumValue(self, root):
            """
            :type root: TreeNode
            :rtype: int
            """
            if not root:
                return -1
            prev=[root]
            minVal=root.val
            secondVal=float('inf')
            while prev:
                cur=[]
                while prev:
                    node=prev.pop()
                    if minVal<node.val and node.val<secondVal:
                        secondVal=node.val
                    if node.left:
                        cur.append(node.left)
                    if node.right:
                        cur.append(node.right)
                prev=cur
            return -1 if secondVal==float('inf') else secondVal

    6、最长同值路径:

    class Solution_iterative:
        def longestUnivaluePath(self, root):
            postorder = [(0, root, None)]
            count = 0
            d = {None: 0}
            while postorder:
                seen, node, parent = postorder.pop()
                if node is None:
                    continue
                if not seen:
                    postorder.append((1, node, parent))
                    postorder.append((0, node.right, node.val))
                    postorder.append((0, node.left, node.val))
                else:
                    if node.val == parent:
                        d[node] = max(d[node.left], d[node.right]) + 1
                    else:
                        d[node] = 0
                    count = max(count, d[node.left] + d[node.right])
    
            return count

    7、判断一棵树是否为高度平衡二叉树

        def isBalanced(self, root):
            stack = [(0, root)]
            depth = {None: 0}
            while stack:
                seen, node = stack.pop()
                if node is None:
                    continue
                if not seen:
                    stack.extend([(1, node), (0, node.right), (0, node.left)])
                else:
                    if abs(depth[node.left] - depth[node.right]) > 1:
                        return False
                    depth[node] = max(depth[node.left], depth[node.right]) + 1
            return True
  • 相关阅读:
    Python采用struct处理二进制
    OVS处理upcall流程分析
    mybatis在CRUD
    leetcode先刷_Valid Sudoku
    [TS] Implement a doubly linked list in TypeScript
    [TS] Implement a singly linked list in TypeScript
    [Python] The get() method on Python dicts and its "default" arg
    [Javascript AST] 4. Continue: Report ESLint error
    [RxJS] Learn How To Use RxJS 5.5 Beta 2
    [NPM] Update published npm packages using np
  • 原文地址:https://www.cnblogs.com/Lee-yl/p/9113870.html
Copyright © 2011-2022 走看看