LeetCode-Python-199. 二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

思路：

先把二叉树的层序遍历搞定，然后把每一层最后一个加入到result里即可。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        next_layer = [root]
        result = [root.val]
        while(next_layer):
            temp_next_layer = []
            for node in next_layer:
                if not node:
                    continue
                if node.left:
                    temp_next_layer.append(node.left)
                if node.right:
                    temp_next_layer.append(node.right)
            # print temp_next_layer[0].val
            if temp_next_layer:
                next_layer = temp_next_layer
                result.append(temp_next_layer[-1].val)
                # print result
            else:
                break
            
        return result
                

下面的层序遍历写于2019年7月24日12:41:32 

class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        queue = [root]
        res = []
        while queue:
            next_queue, layer = [], []
            for node in queue:
                if node:
                    layer.append(node.val)
                    next_queue += [node.left, node.right]
            queue = next_queue[:]
            if layer:
                res.append(layer[-1])
        return res

第二种思路：

利用前序遍历+哈希表，记录下每一层最后访问的最右节点的值。 

class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        dic = dict()
        
        def dfs(root, depth):
            if not root:
                return
            dic[depth] = root.val
            dfs(root.left, depth + 1)
            dfs(root.right, depth + 1)
        dfs(root, 0)
        return list(dic.values())

第三种思路：

DFS搜索，先右子树再左子树的搜索顺序，这样保障每一层搜索到的第一个节点都是最右的节点，

当搜索到新的一层时，就把第一个有效节点放到答案里。

class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        def dfs(node, depth):
            if not node:
                return
            if depth > len(res):
                res.append(node.val)
            dfs(node.right, depth + 1)
            dfs(node.left, depth +1)
            
            
        dfs(root, 1)
        return res