feat: add Serialize and Deserialize Binary Tree

wislertt · wislertt · commit d40fce4cd828 · 2025-09-06T13:28:30.000+07:00
diff --git a/.templates/leetcode/json/serialize_and_deserialize_binary_tree.json b/.templates/leetcode/json/serialize_and_deserialize_binary_tree.json
@@ -0,0 +1,52 @@
+{
+    "problem_name": "serialize_and_deserialize_binary_tree",
+    "solution_class_name": "Codec",
+    "problem_number": "297",
+    "problem_title": "Serialize and Deserialize Binary Tree",
+    "difficulty": "Hard",
+    "topics": "String, Tree, Depth-First Search, Breadth-First Search, Design, Binary Tree",
+    "tags": ["grind-75"],
+    "readme_description": "Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.\n\nDesign an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.\n\n**Clarification:** The input/output format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2020/09/15/serdeser.jpg)\n\n```\nInput: root = [1,2,3,null,null,4,5]\nOutput: [1,2,3,null,null,4,5]\n```"
+        },
+        { "content": "```\nInput: root = []\nOutput: []\n```" }
+    ],
+    "readme_constraints": "- The number of nodes in the tree is in the range [0, 10^4].\n- -1000 <= Node.val <= 1000",
+    "readme_additional": "",
+    "solution_imports": "from leetcode_py import TreeNode",
+    "solution_methods": [
+        { "name": "__init__", "parameters": "", "return_type": "", "dummy_return": "" },
+        {
+            "name": "serialize",
+            "parameters": "root: TreeNode | None",
+            "return_type": "str",
+            "dummy_return": "''"
+        },
+        {
+            "name": "deserialize",
+            "parameters": "data: str",
+            "return_type": "TreeNode | None",
+            "dummy_return": "None"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom leetcode_py import TreeNode\nfrom .solution import Codec",
+    "test_class_name": "SerializeAndDeserializeBinaryTree",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.codec = Codec()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_serialize_deserialize",
+            "parametrize": "root_list",
+            "parametrize_typed": "root_list: list[int | None]",
+            "test_cases": "[([1, 2, 3, None, None, 4, 5]), ([]), ([1]), ([1, 2]), ([1, None, 2]), ([1, 2, 3, 4, 5, 6, 7]), ([5, 2, 3, None, None, 2, 4, 3, 1])]",
+            "body": "root = TreeNode.from_list(root_list) if root_list else None\nserialized = self.codec.serialize(root)\ndeserialized = self.codec.deserialize(serialized)\nif root is None:\n    assert deserialized is None\nelse:\n    assert deserialized is not None\n    assert deserialized.to_list() == root.to_list()"
+        }
+    ],
+    "playground_imports": "from solution import Codec\nfrom leetcode_py import TreeNode",
+    "playground_test_case": "# Example test case\nroot_list = [1, 2, 3, None, None, 4, 5]\nroot = TreeNode.from_list(root_list) if root_list else None",
+    "playground_execution": "codec = Codec()\nserialized = codec.serialize(root)\ndeserialized = codec.deserialize(serialized)\nprint(f'Original: {root.to_list() if root else None}')\nprint(f'Serialized: {serialized}')\nprint(f'Deserialized: {deserialized.to_list() if deserialized else None}')\ndeserialized",
+    "playground_assertion": "if root is None:\n    assert deserialized is None\nelse:\n    assert deserialized is not None\n    assert deserialized.to_list() == root.to_list()"
+}
diff --git a/.templates/leetcode/{{cookiecutter.problem_name}}/solution.py b/.templates/leetcode/{{cookiecutter.problem_name}}/solution.py
@@ -4,7 +4,7 @@ class {{cookiecutter.solution_class_name}}:
     {%- for _, methods in cookiecutter._solution_methods | dictsort %}
     {%- for method in methods %}
     # Time: O(?)
-    # Space: O(?){# TODO: add decorator // optional self. #}
+    # Space: O(?){# TODO: add decorator // optional self. // optional return type // optional return #}
     def {{method.name}}(self, {{method.parameters}}) -> {{method.return_type}}:
         # TODO: Implement {{method.name}}{# TODO: add body #}
         return {{method.dummy_return}}
diff --git a/Makefile b/Makefile
@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= word_ladder
+PROBLEM ?= serialize_and_deserialize_binary_tree
 FORCE ?= 0
 COMMA := ,
 
diff --git a/leetcode/serialize_and_deserialize_binary_tree/README.md b/leetcode/serialize_and_deserialize_binary_tree/README.md
@@ -0,0 +1,38 @@
+# Serialize and Deserialize Binary Tree
+
+**Difficulty:** Hard
+**Topics:** String, Tree, Depth-First Search, Breadth-First Search, Design, Binary Tree
+**Tags:** grind-75
+
+**LeetCode:** [Problem 297](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/description/)
+
+## Problem Description
+
+Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
+
+Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.
+
+**Clarification:** The input/output format is the same as how LeetCode serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2020/09/15/serdeser.jpg)
+
+```
+Input: root = [1,2,3,null,null,4,5]
+Output: [1,2,3,null,null,4,5]
+```
+
+### Example 2:
+
+```
+Input: root = []
+Output: []
+```
+
+## Constraints
+
+- The number of nodes in the tree is in the range [0, 10^4].
+- -1000 <= Node.val <= 1000
diff --git a/leetcode/serialize_and_deserialize_binary_tree/__init__.py b/leetcode/serialize_and_deserialize_binary_tree/__init__.py
diff --git a/leetcode/serialize_and_deserialize_binary_tree/playground.ipynb b/leetcode/serialize_and_deserialize_binary_tree/playground.ipynb
@@ -0,0 +1,167 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Codec\n",
+    "\n",
+    "from leetcode_py import TreeNode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "root_list = [1, 2, 3, None, None, 4, 5]\n",
+    "root = TreeNode.from_list(root_list) if root_list else None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Original: [1, 2, 3, None, None, 4, 5]\n",
+      "Serialized: 1,2,#,#,3,4,#,#,5,#,#\n",
+      "Deserialized: [1, 2, 3, None, None, 4, 5]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 13.1.2 (20250808.2320)\n",
+       " -->\n",
+       "<!-- Pages: 1 -->\n",
+       "<svg width=\"170pt\" height=\"188pt\"\n",
+       " viewBox=\"0.00 0.00 170.00 188.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 184)\">\n",
+       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-184 166,-184 166,4 -4,4\"/>\n",
+       "<!-- 0 -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>0</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"63\" cy=\"-162\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"63\" y=\"-156.95\" font-family=\"Times,serif\" font-size=\"14.00\">1</text>\n",
+       "</g>\n",
+       "<!-- 1 -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>1</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"27\" cy=\"-90\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"27\" y=\"-84.95\" font-family=\"Times,serif\" font-size=\"14.00\">2</text>\n",
+       "</g>\n",
+       "<!-- 0&#45;&gt;1 -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>0&#45;&gt;1</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M54.65,-144.76C50.42,-136.55 45.19,-126.37 40.42,-117.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"43.68,-115.79 36,-108.49 37.46,-118.99 43.68,-115.79\"/>\n",
+       "</g>\n",
+       "<!-- 2 -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>2</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"99\" cy=\"-90\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"99\" y=\"-84.95\" font-family=\"Times,serif\" font-size=\"14.00\">3</text>\n",
+       "</g>\n",
+       "<!-- 0&#45;&gt;2 -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>0&#45;&gt;2</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M71.35,-144.76C75.58,-136.55 80.81,-126.37 85.58,-117.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"88.54,-118.99 90,-108.49 82.32,-115.79 88.54,-118.99\"/>\n",
+       "</g>\n",
+       "<!-- 3 -->\n",
+       "<g id=\"node4\" class=\"node\">\n",
+       "<title>3</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"63\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"63\" y=\"-12.95\" font-family=\"Times,serif\" font-size=\"14.00\">4</text>\n",
+       "</g>\n",
+       "<!-- 2&#45;&gt;3 -->\n",
+       "<g id=\"edge3\" class=\"edge\">\n",
+       "<title>2&#45;&gt;3</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M90.65,-72.76C86.42,-64.55 81.19,-54.37 76.42,-45.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"79.68,-43.79 72,-36.49 73.46,-46.99 79.68,-43.79\"/>\n",
+       "</g>\n",
+       "<!-- 4 -->\n",
+       "<g id=\"node5\" class=\"node\">\n",
+       "<title>4</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"135\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"135\" y=\"-12.95\" font-family=\"Times,serif\" font-size=\"14.00\">5</text>\n",
+       "</g>\n",
+       "<!-- 2&#45;&gt;4 -->\n",
+       "<g id=\"edge4\" class=\"edge\">\n",
+       "<title>2&#45;&gt;4</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M107.35,-72.76C111.58,-64.55 116.81,-54.37 121.58,-45.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"124.54,-46.99 126,-36.49 118.32,-43.79 124.54,-46.99\"/>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "TreeNode([1, 2, 3, None, None, 4, 5])"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "codec = Codec()\n",
+    "serialized = codec.serialize(root)\n",
+    "deserialized = codec.deserialize(serialized)\n",
+    "print(f\"Original: {root.to_list() if root else None}\")\n",
+    "print(f\"Serialized: {serialized}\")\n",
+    "print(f\"Deserialized: {deserialized.to_list() if deserialized else None}\")\n",
+    "deserialized"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if root is None:\n",
+    "    assert deserialized is None\n",
+    "else:\n",
+    "    assert deserialized is not None\n",
+    "    assert deserialized.to_list() == root.to_list()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/leetcode/serialize_and_deserialize_binary_tree/solution.py b/leetcode/serialize_and_deserialize_binary_tree/solution.py
@@ -0,0 +1,81 @@
+from leetcode_py import TreeNode
+
+
+class Codec:
+    # Preorder with Null Markers
+    # Time: O(n)
+    # Space: O(n)
+    def serialize(self, root: TreeNode | None) -> str:
+        vals = []
+
+        def dfs(node: TreeNode | None):
+            if not node:
+                vals.append("#")
+                return
+            vals.append(str(node.val))
+            dfs(node.left)
+            dfs(node.right)
+
+        dfs(root)
+        return ",".join(vals)
+
+    # Time: O(n)
+    # Space: O(n)
+    def deserialize(self, data: str) -> TreeNode | None:
+        vals = iter(data.split(","))
+
+        def dfs():
+            val = next(vals)
+            if val == "#":
+                return None
+            node = TreeNode(int(val))
+            node.left = dfs()
+            node.right = dfs()
+            return node
+
+        return dfs()
+
+
+# Binary Tree Serialization Techniques
+
+# Example Tree:
+#       1
+#      / \
+#     2   3
+#        / \
+#       4   5
+
+# 1. Preorder with Null Markers (This Implementation)
+# Visit: root → left → right, mark nulls with '#'
+# Result: "1,2,#,#,3,4,#,#,5,#,#"
+# Pros: Self-contained, unambiguous, O(n) reconstruction
+# Cons: Longer string due to null markers
+
+# 2. Level-order (BFS) with Null Markers
+# Visit level by level, mark nulls with '#'
+# Result: "1,2,3,#,#,4,5"
+# Pros: Simple format like preorder, level-by-level intuitive
+# Cons: Still requires queue processing
+
+# 3. Postorder with Null Markers
+# Visit: left → right → root
+# Result: "#,#,2,#,#,4,#,#,5,3,1"
+# Pros: Bottom-up reconstruction
+# Cons: Less intuitive than preorder
+
+# 4. Inorder + Preorder (Two Arrays)
+# Inorder: [2,1,4,3,5], Preorder: [1,2,3,4,5]
+# Pros: Works for any binary tree structure
+# Cons: Requires two arrays, only works with unique values
+
+# 5. Parenthetical Preorder
+# Same traversal as #1 but with parentheses format: value(left)(right)
+# Result: "1(2()())(3(4()())(5()()))"
+# Pros: Human readable structure, shows nesting clearly
+# Cons: Complex parsing, verbose
+
+# 6. Parenthetical Postorder
+# Same traversal as #3 but with parentheses format: (left)(right)value
+# Result: "(()()2)((()()4)(()()5)3)1"
+# Pros: Bottom-up readable structure
+# Cons: Even more complex parsing
diff --git a/leetcode/serialize_and_deserialize_binary_tree/tests.py b/leetcode/serialize_and_deserialize_binary_tree/tests.py
