[Leetcode]由Binary Tree Right Side View说起

最新推荐文章于 2024-01-19 11:16:08 发布

原创最新推荐文章于 2024-01-19 11:16:08 发布 · 370 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Leetcode #BFS #DFS #层次遍历

leetcode 专栏收录该内容

6 篇文章

订阅专栏

本文深入探讨了二叉树相关题目，包括层次遍历、最深与最浅节点求解、二叉树的视图展示等核心内容，通过详细代码与分析，帮助读者掌握二叉树的基本操作与理解层次遍历的多种实现方式。

1. Binary Tree Right Side View

Binary Tree Right Side View应该是一道最近刚加上的新题。看着不难，我就试着做了做。

前两天看到这个题，就想到层次用DFS和层深度，找到每层最后一个节点。代码如下：

class Solution:
    # @param root, a tree node
    # @return a list of integers
    def rightSideView(self, root):
        nodeStack = []
        ret = []  #返回结果
        if root == None:
            return ret
        nodeStack.append(root)
        depth = [0]  #与nodeStack对应的节点深度list
        while nodeStack:  #dfs，空列表[]相当于False
            tmp = nodeStack.pop()
            d = depth.pop()
            if len(ret) <= d:  #如果ret中元素的个数不大于深度，说明该层的最后一个节点还没有加入
                ret.append(tmp.val)
            if tmp.left:
            #深度+1，左子节点入栈
                d += 1
                nodeStack.append(tmp.left)
                depth.append(d)
            if tmp.right:
            #深度+1（如果没有左子），右子节点入栈
                if not tmp.left: d += 1
                nodeStack.append(tmp.right)
                depth.append(d)

        return ret

当然，最好的方法还是直接用层次遍历。

class Solution:
    # @param root, a tree node
    # @return a list of integers
    def rightSideView(self, root):
        nodeQueue = []
        ret = []
        if root == None:
            return ret
        nodeQueue.append(root)
        while nodeQueue:
            qLen = len(nodeQueue) #刚进入while循环，qLen能得到当前层上的节点数
            for i in xrange(qLen):
                tmp = nodeQueue.pop(0)
                if i == qLen - 1:  #每次只记录层次遍历的最后一个节点
                    ret.append(tmp.val)
                if tmp.left:
                    nodeQueue.append(tmp.left)
                if tmp.right:
                    nodeQueue.append(tmp.right)
        return ret

思路和代码都不难理解。
那么一鼓作气，我们就顺便把其他几个简单的BFS/DFS题做了。

2.Maximum/Minimum Depth of Binary Tree

求深度，一个求最大，一个求最小。

最小深度

相对来说，我觉得最小深度更容易：BFS，一旦遇到一个叶节点，返回~
下面的程序中，我们直接把深度存到节点的val域里面去了（反正也用不上）。

class Solution:
    # @param root, a tree node
    # @return an integer
    def minDepth(self, root):
        if root == None: return 0
        root.val = 1
        a_queue = []
        a_queue.append(root)
        cur = None
        while a_queue:
            cur = a_queue.pop(0)
            if cur.left == None and cur.right == None:  #leaf node!
                return cur.val
            if cur.left:
                cur.left.val = cur.val + 1
                a_queue.append(cur.left)
            if cur.right:
                cur.right.val = cur.val + 1
                a_queue.append(cur.right)

最大深度

既可以用BFS做，也可以用DFS做。下面是BFS的代码。与minDepth差别是，这次我们要把所有节点都走一遍。队列中最后出队的节点，就是最深的那个。

class Solution:
    # @param root, a tree node
    # @return an integer
    def maxDepth(self, root):
        if root == None: return 0
        root.val = 1
        a_queue = []
        a_queue.append(root)
        cur_root = None
        while a_queue:
            cur_root = a_queue.pop(0)
            if cur_root.left:
                cur_root.left.val = cur_root.val + 1
                a_queue.append(cur_root.left)
            if cur_root.right:
                cur_root.right.val = cur_root.val + 1
                a_queue.append(cur_root.right)
        return cur_root.val

如果用DFS的话，直接递归，效率不高，但超简洁。

class Solution:
    # @param root, a tree node
    # @return an integer
    def maxDepth(self, root):
        if root == None:
            return 0
        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1

Binary Tree Level Order Traversal/II/Zigzag Level Order Traversal

这几个就是简单粗暴的层次遍历了，只不过是变一下花样。也许各有各的特别的高效率做法，我还没有查。后续补充。

Binary Tree Level Order Traversal

基础版层次遍历很简单，前文的代码改一改就可以了。

class Solution:
    # @param root, a tree node
    # @return a list of lists of integers
    def levelOrder(self, root):
        nodeQueue = []
        ret = []
        if root == None:
            return ret
        nodeQueue.append(root)
        while nodeQueue:
            qLen = len(nodeQueue)
            thisLevel = []  #当前层的子list
            for i in xrange(qLen):
                tmp = nodeQueue.pop(0)
                thisLevel.append(tmp.val)
                if tmp.left:
                    nodeQueue.append(tmp.left)
                if tmp.right:
                    nodeQueue.append(tmp.right)
            ret.append(thisLevel)

        return ret

效率稍差，可能还有优化的潜力。

Binary Tree Level Order Traversal II

II的差别就是从底向上层次遍历……我就直接把上面的程序改了一行……

        return ret[::-1]

我知道这样很不好，人家出题不可能这么无脑的。所以还会在看看。无论如何，结果是对的。

Binary Tree Zigzag Level Order Traversal

差别是，这次是蛇形的层次遍历：奇数行从左到右，偶数行从右到左。

class Solution:
    # @param root, a tree node
    # @return a list of lists of integers
    def zigzagLevelOrder(self, root):
        nodeQueue = []
        ret = []
        if root == None:
            return ret
        nodeQueue.append(root)
        level = 1
        while nodeQueue:
            qLen = len(nodeQueue)
            thisLevel = []
            for i in xrange(qLen):
                tmp = nodeQueue.pop(0)
                thisLevel.append(tmp.val)
                if tmp.left:
                    nodeQueue.append(tmp.left)
                if tmp.right:
                    nodeQueue.append(tmp.right)
            #新加的内容
            if level & 1:
                ret.append(thisLevel)
            else:
                ret.append(thisLevel[::-1])
            level += 1
            #...

        return ret