feat: add solutions to lc problem: No.0297

No.0297.Serialize and Deserialize Binary Tree

Author: yanglbme

solution/0200-0299/0297.Serialize and Deserialize Binary Tree/README.md

@@ -51,7 +51,6 @@
 	<li><code>-1000 <= Node.val <= 1000</code></li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
@@ -63,15 +62,184 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Codec:
+
+    def serialize(self, root):
+        """Encodes a tree to a single string.
+        
+        :type root: TreeNode
+        :rtype: str
+        """
+
+        if root is None:
+            return ''
+        res = []
+
+        def preorder(root):
+            if root is None:
+                res.append("#,")
+                return
+            res.append(str(root.val) + ",")
+            preorder(root.left)
+            preorder(root.right)
+        
+        preorder(root)
+        return ''.join(res)
+        
+
+    def deserialize(self, data):
+        """Decodes your encoded data to tree.
+        
+        :type data: str
+        :rtype: TreeNode
+        """
+        if not data:
+            return None
+        vals = data.split(',')
+
+        def inner():
+            first = vals.pop(0)
+            if first == '#':
+                return None
+            return TreeNode(int(first), inner(), inner())
+        
+        return inner()
+
+# Your Codec object will be instantiated and called as such:
+# ser = Codec()
+# deser = Codec()
+# ans = deser.deserialize(ser.serialize(root))
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Codec {
+    private static final String NULL = "#";
+    private static final String SEP = ",";
+
+    // Encodes a tree to a single string.
+    public String serialize(TreeNode root) {
+        if (root == null) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder();
+        preorder(root, sb);
+        return sb.toString();
+    }
+
+    private void preorder(TreeNode root, StringBuilder sb) {
+        if (root == null) {
+            sb.append(NULL + SEP);
+            return;
+        }
+        sb.append(root.val + SEP);
+        preorder(root.left, sb);
+        preorder(root.right, sb);
+    }
+
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        if (data == null || "".equals(data)) {
+            return null;
+        }
+        List<String> vals = new LinkedList<>();
+        for (String x : data.split(SEP)) {
+            vals.add(x);
+        }
+        return deserialize(vals);
+    }
+
+    private TreeNode deserialize(List<String> vals) {
+        String first = vals.remove(0);
+        if (NULL.equals(first)) {
+            return null;
+        }
+        TreeNode root = new TreeNode(Integer.parseInt(first));
+        root.left = deserialize(vals);
+        root.right = deserialize(vals);
+        return root;
+    }
+}
 
+// Your Codec object will be instantiated and called as such:
+// Codec ser = new Codec();
+// Codec deser = new Codec();
+// TreeNode ans = deser.deserialize(ser.serialize(root));
+```
+
+### **C++**
+
+```cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Codec {
+public:
+
+    // Encodes a tree to a single string.
+    string serialize(TreeNode* root) {
+        if (!root) return "";
+        string s = "";
+        preorder(root, s);
+        return s;
+    }
+
+    void preorder(TreeNode* root, string& s) {
+        if (!root) s += "# ";
+        else
+        {
+            s += to_string(root->val) + " ";
+            preorder(root->left, s);
+            preorder(root->right, s);
+        }
+    }
+
+    // Decodes your encoded data to tree.
+    TreeNode* deserialize(string data) {
+        if (data == "") return nullptr;
+        stringstream ss(data);
+        return deserialize(ss);
+    }
+
+    TreeNode* deserialize(stringstream& ss) {
+        string first;
+        ss >> first;
+        if (first == "#") return nullptr;
+        TreeNode* root = new TreeNode(stoi(first));
+        root->left = deserialize(ss);
+        root->right = deserialize(ss);
+        return root;
+    }
+};
+
+// Your Codec object will be instantiated and called as such:
+// Codec ser, deser;
+// TreeNode* ans = deser.deserialize(ser.serialize(root));
 ```
 
 ### **JavaScript**
@@ -91,20 +259,8 @@
  * @param {TreeNode} root
  * @return {string}
  */
-var serialize = function (root) {
-    let data = [];
-    let serializeRec = function (root) {
-        if (!root) {
-            data.push(1001);
-            return null;
-        }
-        data.push(root.val);
-
-        serializeRec(root.left);
-        serializeRec(root.right);
-    }
-    serializeRec(root);
-    return data;
+var serialize = function(root) {
+    return rserialize(root, '');
 };
 
 /**
@@ -113,19 +269,35 @@ var serialize = function (root) {
  * @param {string} data
  * @return {TreeNode}
  */
-var deserialize = function (data) {
-    if (!data) {
-        return null;
+var deserialize = function(data) {
+    const dataArray = data.split(",");
+    return rdeserialize(dataArray);
+};
+
+const rserialize = (root, str) => {
+    if (root === null) {
+        str += "#,";
+    } else {
+        str += root.val + '' + ",";
+        str = rserialize(root.left, str);
+        str = rserialize(root.right, str);
     }
-    let curVal = data.shift();
-    if (curVal == 1001) {
+    return str;
+}
+
+const rdeserialize = (dataList) => {
+    if (dataList[0] === "#") {
+        dataList.shift();
         return null;
     }
-    let node = new TreeNode(curVal);
-    node.left = deserialize(data);
-    node.right = deserialize(data);
-    return node;
-};
+
+    const root = new TreeNode(parseInt(dataList[0]));
+    dataList.shift();
+    root.left = rdeserialize(dataList);
+    root.right = rdeserialize(dataList);
+
+    return root;
+}
 
 /**
  * Your functions will be called as such: