Update 199._binary_tree_right_side_view.md

Author: 0xkookoo

docs/Leetcode_Solutions/Python/199._binary_tree_right_side_view.md

@@ -1,74 +1,62 @@
-###199. Binary Tree Right Side View
+# 199. Binary Tree Right Side View
 
-题目:
+**<font color=red>难度: Medium</font>**
 
-<https://leetcode.com/problems/binary-tree-right-side-view/>
+## 刷题内容
 
+> 原题连接
 
-难度:
+* https://leetcode.com/problems/binary-tree-right-side-view/description/
 
-Medium
+> 内容描述
 
+```
 
-还是在玩第102题，level order traversal.
+Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.
 
-```
-class Solution(object):
-    def rightSideView(self, root):
-        """
-        :type root: TreeNode
-        :rtype: List[int]
-        """
-        if root == None: return []
-      
-        res = []
-        curLevel = [root]
-        while curLevel:
-            nextLevel = []
-            tmpRes = []
-            for node in curLevel:
-                tmpRes.append(node.val)
-                if node.left: nextLevel.append(node.left)
-                if node.right: nextLevel.append(node.right)
-            res.append(tmpRes[-1])
-            curLevel = nextLevel
-        return res
-```
+Example:
 
+Input: [1,2,3,null,5,null,4]
+Output: [1, 3, 4]
+Explanation:
 
-另一个解法
+   1            <---
+ /   \
+2     3         <---
+ \     \
+  5     4       <---
+```
 
-**解题思路**
+## 解题方案
 
-这个题目还是挺有意思的，它还可以问左视图。解法上，直观些，取得每一层的最右边一个元素即可。既然取每一层最右边元素，那就要对二叉树进行层次遍历，层次遍历比较简单，就是使用一个队列，进队根节点，然后循环，出队列一个元素，左子树不空就进队，右子树不空就进队，直到队列为空时停止循环。但要想取得每层的最右一个元素，难点是**如何知道当前节点是哪一层**。
+> 思路 1
+******- 时间复杂度: O(N)******- 空间复杂度: O(N)******
 
-对于一棵树，除了根节点，其他节点我们都不能直接知道它是哪一层，但是根节点我们肯定知道是第一层。那根节点的左右孩子节点是第几次？推广一下，如果我们知道节点 `x` 是第 `k` 层，那节点 `x` 的左右子节点是第几层？回答出这个问题，难点就迎刃而解了。
 
-我们在层次遍历的队列里为每个节点增加一个字段表示深度（即该节点在第几层），然后在其子节点入队列的时候，设置子节点的深度为父节点的深度加一。因为我们知道根节点的深度，所以可以很容易的递推下去。
+还是在玩第102题，level order traversal. beats 100%
 
 ```python
-class Solution:
+class Solution(object):
     def rightSideView(self, root):
         """
         :type root: TreeNode
         :rtype: List[int]
         """
-        if not root:  # 特殊情况检查
+        if not root:
             return []
-        queue, seq = [(1, root)], []  # queue为层次遍历的操作队列，seq保存遍历的结果
-        while queue:
-            deep, node = queue.pop(0)  # queue 内的元素是个（deep, node）二元组
-            seq.append((deep, node.val))  # seq 内的元素是个（deep, node.val）二元组
-            if node.left:
-                queue.append((deep+1, node.left))
-            if node.right:
-                queue.append((deep+1, node.right))
-        last, out = -1, []  # 因为要同层的最右边一个，也就是seq中，deep相同的几个里面最后一个
-        for deep, val in reversed(seq):  # 所以将seq反转，deep相同的第一个即最右一个
-            if deep != last:  # last 表示前一层的deep值
-                last = deep
-                out.append(val)
-        return list(reversed(out))  # 最后把结果反转回来
+      
+        res = []
+        cur_level = [root]
+        while cur_level:
+            next_level, tmp_res = [], []
+            for node in cur_level:
+                tmp_res.append(node.val)
+                if node.left: 
+                    next_level.append(node.left)
+                if node.right: 
+                    next_level.append(node.right)
+            res.append(tmp_res[-1])
+            cur_level = next_level
+        return res
 ```
 
-用时 52ms，战胜 86% python3 提交。