【Leetcode】637. Average of Levels in Binary Tree 解题报告

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/dpengwang/article/details/88218702

求二叉树每一层的平局值

思路

其实就是层次遍历的方法，再除以每层的节点数就行了，层次遍历的各种写法都可以用

方法1 深搜非递归

class Solution1(object):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if root == None:
            return []
        res = []
        stack = [[root,0]]
        while(len(stack)):
            node, level = stack.pop()
            if len(res) < level+1:
                res.append([])
            res[level].append(node.val)
            if node.left:
                stack.append([node.left, level+1])
            if node.right:
                stack.append([node.right, level+1])
        return list(map(lambda x: float(sum(x))/len(x), res))

方法2 深搜递归

class Solution2(object):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if root == None:
            return []
        self.res = []
        self.DFS(root, 1)
        return list(map(lambda x:float(sum(x))/len(x), self.res))

    def DFS(self, root, level):
        if root == None:
            return
        if len(self.res) < level:
            self.res.append([])
        self.res[level-1].append(root.val)
        self.DFS(root.left, level+1)
        self.DFS(root.right, level+1)

方法3 层次遍历非递归

class Solution3(object):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if root == None:
            return []
        from collections import deque
        queue = deque()
        queue.append(root)
        res = []
        while(len(queue)):
            length = len(queue)
            tmp = 0
            for i in range(length):
                node = queue.popleft()
                tmp += node.val
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(float(tmp/length))
        return res

改进一下，通过两个变量相互交换，不用每次求当前层的宽度，可以beat 100%

class Solution4(object):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if root == None:
            return []
        stack = [root]
        res = []
        while(len(stack)):
            tmp = []
            sumer = 0
            for node in stack:
                sumer += node.val
                if node.left:
                    tmp.append(node.left)
                if node.right:
                    tmp.append(node.right)
            res.append(float(sumer)/len(stack))
            stack = tmp
        return res