solve problem Binary Tree Paths

Author: P-ppc

README.md

@@ -59,6 +59,7 @@ All solutions will be accepted!
 |118|[Pascals Triangle](https://leetcode-cn.com/problems/pascals-triangle/description/)|[java/py/js](./algorithms/PascalsTriangle)|Easy|
 |303|[Range Sum Query Immutable](https://leetcode-cn.com/problems/range-sum-query-immutable/description/)|[java/py/js](./algorithms/RangeSumQueryImmutable)|Easy|
 |412|[Fizz Buzz](https://leetcode-cn.com/problems/fizz-buzz/description/)|[java/py/js](./algorithms/FizzBuzz)|Easy|
+|257|[Binary Tree Paths](https://leetcode-cn.com/problems/binary-tree-paths/description/)|[java/py/js](./algorithms/BinaryTreePaths)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/BinaryTreePaths/README.md

@@ -0,0 +1,2 @@
+# Binary Tree Paths
+This problem is easy to solve

algorithms/BinaryTreePaths/Solution.java

@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<String> binaryTreePaths(TreeNode root) {
+        List<String> res = new ArrayList<String>();
+        List<Map<String, Object>> paths = new ArrayList<Map<String, Object>>();
+        
+        if (root == null) return res;
+        
+        Map<String, Object> rootPath = new HashMap<String, Object>();
+        rootPath.put("node", root);
+        rootPath.put("path", String.valueOf(root.val));
+        paths.add(rootPath);
+        
+        while (paths.size() > 0) {
+            Map<String, Object> nodePath = paths.get(paths.size() - 1);
+            paths.remove(paths.size() - 1);
+            TreeNode node = (TreeNode) nodePath.get("node");
+            String path = (String) nodePath.get("path");
+            if (node.left == null && node.right == null) {
+                res.add(path);
+            } 
+            if (node.left != null) {
+                nodePath = new HashMap<String, Object>();
+                nodePath.put("node", node.left);
+                nodePath.put("path", path + "->" + String.valueOf(node.left.val));
+                paths.add(nodePath);
+            }
+            if (node.right != null) {
+                nodePath = new HashMap<String, Object>();
+                nodePath.put("node", node.right);
+                nodePath.put("path", path + "->" + String.valueOf(node.right.val));
+                paths.add(nodePath);
+            }
+        }
+        
+        return res;
+    }
+}

algorithms/BinaryTreePaths/solution.js

@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {string[]}
+ */
+var binaryTreePaths = function(root) {
+    if (root === null) {
+        return []
+    }
+    
+    let res = [],
+        paths = [
+            {
+                node: root,
+                path: String(root.val)
+            }
+        ]
+    
+    while (paths.length > 0) {
+        let path = paths.pop()
+        if (path.node.left === null && path.node.right === null) {
+            res.push(path.path)
+        }
+        if (path.node.left !== null) {
+            paths.push({
+                node: path.node.left,
+                path: path.path + '->' + String(path.node.left.val)
+            })
+        }
+        if (path.node.right !== null) {
+            paths.push({
+                node: path.node.right,
+                path: path.path + '->' + String(path.node.right.val)
+            })
+        }
+    }
+    return res
+};

algorithms/BinaryTreePaths/solution.py

@@ -0,0 +1,37 @@
+# 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 binaryTreePaths(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[str]
+        """
+        if not root:
+            return []
+        paths = [
+            {
+                'node': root,
+                'path': str(root.val)
+            }
+        ]
+        res = []
+        while len(paths) > 0:
+            path = paths.pop()
+            if not path['node'].left and not path['node'].right:
+                res.append(path['path'])
+            if path['node'].right:
+                paths.append({
+                    'node': path['node'].right,
+                    'path': path['path'] + '->' + str(path['node'].right.val)
+                })
+            if path['node'].left:
+                paths.append({
+                    'node': path['node'].left,
+                    'path': path['path'] + '->' + str(path['node'].left.val)
+                })
+        return res