solve problem Binary Tree Right Side View

Author: P-ppc

README.md

@@ -251,6 +251,7 @@ All solutions will be accepted!
 |24|[Swap Nodes In Pairs](https://leetcode-cn.com/problems/swap-nodes-in-pairs/description/)|[java/py/js](./algorithms/SwapNodesInPairs)|Medium|
 |143|[Reorder List](https://leetcode-cn.com/problems/reorder-list/description/)|[java/py/js](./algorithms/ReorderList)|Medium|
 |515|[Find Largest Value In Each Tree Row](https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/description/)|[java/py/js](./algorithms/FindLargestValueInEachTreeRow)|Medium|
+|199|[Binary Tree Right Side View](https://leetcode-cn.com/problems/binary-tree-right-side-view/description/)|[java/py/js](./algorithms/BinaryTreeRightSideView)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/BinaryTreeRightSideView/README.md

@@ -0,0 +1,2 @@
+# Binary Tree Right Side View
+We can solve this problem by BFS

algorithms/BinaryTreeRightSideView/Solution.java

@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> res = new ArrayList<Integer>();
+        LinkedList<TreeNode> stack = new LinkedList<TreeNode>(),
+                             nextStack = new LinkedList<TreeNode>();
+        LinkedList<Integer> values = new LinkedList<Integer>();
+        
+        if (root != null) stack.addFirst(root);
+        
+        while (stack.size() > 0) {
+            TreeNode node = stack.removeLast();
+            values.addFirst(node.val);
+            
+            if (node.left != null) nextStack.addFirst(node.left);
+            if (node.right != null) nextStack.addFirst(node.right);
+            
+            if (stack.size() == 0) {
+                res.add(values.get(0));
+                values = new LinkedList<Integer>();
+                stack = nextStack;
+                nextStack = new LinkedList<TreeNode>();
+            }
+        }
+        
+        return res;
+    }
+}

algorithms/BinaryTreeRightSideView/solution.js

@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var rightSideView = function(root) {
+    let res = [],
+        stack = [],
+        nextStack = [],
+        values = []
+    
+    if (root) stack.unshift(root)
+    
+    while (stack.length > 0) {
+        let node = stack.pop()
+        values.unshift(node.val)
+        if (node.left) nextStack.unshift(node.left)
+        if (node.right) nextStack.unshift(node.right)
+        
+        if (stack.length == 0) {
+            res.push(values.shift())
+            values = []
+            stack = nextStack
+            nextStack = []
+        }
+    }
+    
+    return res
+};

algorithms/BinaryTreeRightSideView/solution.py

@@ -0,0 +1,34 @@
+# 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]
+        """
+        res = []
+        stack = []
+        next_stack = []
+        values = []
+        
+        if root: stack.insert(0, root)
+        
+        while len(stack) > 0:
+            node = stack.pop()
+            values.insert(0, node.val)
+            
+            if node.left: next_stack.insert(0, node.left)
+            if node.right: next_stack.insert(0, node.right)
+            
+            if len(stack) == 0:
+                res.append(values[0])
+                values = []
+                stack = next_stack
+                next_stack = []
+        
+        return res