solve problem Binary Tree Preorder Traversal

Author: P-ppc

README.md

@@ -41,6 +41,7 @@ All solutions will be accepted!
 |9|[Palindrome Number](https://leetcode-cn.com/problems/palindrome-number/description/)|[java/py/js](./algorithms/PalindromeNumber)|Easy|
 |389|[Find The Difference](https://leetcode-cn.com/problems/find-the-difference/description/)|[java/py/js](./algorithms/FindTheDifference)|Easy|
 |94|[Binary Tree Inorder Traversal](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/description/)|[java/py/js](./algorithms/BinaryTreeInorderTraversal)|Medium|
+|144|[Binary Tree Preorder Traversal](https://leetcode-cn.com/problems/binary-tree-preorder-traversal/description/)|[java/py/js](./algorithms/BinaryTreePreorderTraversal)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/BinaryTreePreorderTraversal/README.md

@@ -0,0 +1,22 @@
+# Binary Tree Preorder Traversal
+Use recursion can easy to solve this problem, like below:
+```
+# 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 preorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        # root -> left -> right
+        if not root:
+            return []
+        return [ root.val ] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)
+```
+But we have to use iteration to solve this problem, the stack is the solution

algorithms/BinaryTreePreorderTraversal/Solution.java

@@ -0,0 +1,28 @@
+/**
+ * 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> preorderTraversal(TreeNode root) {
+        List<TreeNode> stack = new ArrayList<TreeNode>();
+        List<Integer> res = new ArrayList<Integer>();
+        if (root == null) {
+            return res;
+        }
+        
+        stack.add(root);
+        while (stack.size() > 0) {
+            TreeNode node = stack.get(stack.size() - 1);
+            stack.remove(stack.size() - 1);
+            res.add(node.val);
+            if (node.right != null) stack.add(node.right);
+            if (node.left != null) stack.add(node.left);
+        }
+        return res;
+    }
+}

algorithms/BinaryTreePreorderTraversal/solution.js

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

algorithms/BinaryTreePreorderTraversal/solution.py

@@ -0,0 +1,27 @@
+# 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 preorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        # root -> left -> right
+        if not root:
+            return []
+        stack = [root]
+        res = []
+        while len(stack) > 0:
+            node = stack.pop()
+            res.append(node.val)
+            if node.right:
+                stack.append(node.right)
+            if node.left:
+                stack.append(node.left)
+        return res
+