feat: add No.606

Author: BaffinLee

601-700/606. Construct String from Binary Tree.md

@@ -0,0 +1,76 @@
+# 606. Construct String from Binary Tree
+
+- Difficulty: Easy.
+- Related Topics: String, Tree, Depth-First Search, Binary Tree.
+- Similar Questions: Construct Binary Tree from String, Find Duplicate Subtrees.
+
+## Problem
+
+Given the `root` of a binary tree, construct a string consisting of parenthesis and integers from a binary tree with the preorder traversal way, and return it.
+
+Omit all the empty parenthesis pairs that do not affect the one-to-one mapping relationship between the string and the original binary tree.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2021/05/03/cons1-tree.jpg)
+
+```
+Input: root = [1,2,3,4]
+Output: "1(2(4))(3)"
+Explanation: Originally, it needs to be "1(2(4)())(3()())", but you need to omit all the unnecessary empty parenthesis pairs. And it will be "1(2(4))(3)"
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2021/05/03/cons2-tree.jpg)
+
+```
+Input: root = [1,2,3,null,4]
+Output: "1(2()(4))(3)"
+Explanation: Almost the same as the first example, except we cannot omit the first parenthesis pair to break the one-to-one mapping relationship between the input and the output.
+```
+
+ 
+**Constraints:**
+
+
+	
+- The number of nodes in the tree is in the range `[1, 104]`.
+	
+- `-1000 <= Node.val <= 1000`
+
+
+
+## Solution
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {string}
+ */
+var tree2str = function(root) {
+    if (!root) return '';
+    var res = `${root.val}`;
+    if (root.left || root.right) res += `(${tree2str(root.left)})`;
+    if (root.right) res += `(${tree2str(root.right)})`;
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).