feat: add Diameter of Binary Tree

wislertt · wislertt · commit 1e319751a87e · 2025-09-06T20:20:52.000+07:00
diff --git a/.templates/leetcode/json/diameter_of_binary_tree.json b/.templates/leetcode/json/diameter_of_binary_tree.json
@@ -0,0 +1,45 @@
+{
+    "problem_name": "diameter_of_binary_tree",
+    "solution_class_name": "Solution",
+    "problem_number": "543",
+    "problem_title": "Diameter of Binary Tree",
+    "difficulty": "Easy",
+    "topics": "Tree, Depth-First Search, Binary Tree",
+    "tags": ["grind-75"],
+    "readme_description": "Given the `root` of a binary tree, return the length of the **diameter** of the tree.\n\nThe **diameter** of a binary tree is the **length** of the longest path between any two nodes in a tree. This path may or may not pass through the `root`.\n\nThe **length** of a path between two nodes is represented by the number of edges between them.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2021/03/06/diamtree.jpg)\n\n```\nInput: root = [1,2,3,4,5]\nOutput: 3\n```\n**Explanation:** 3 is the length of the path [4,2,1,3] or [5,2,1,3]."
+        },
+        { "content": "```\nInput: root = [1,2]\nOutput: 1\n```" }
+    ],
+    "readme_constraints": "- The number of nodes in the tree is in the range [1, 10^4].\n- -100 <= Node.val <= 100",
+    "readme_additional": "",
+    "solution_imports": "from leetcode_py import TreeNode",
+    "solution_methods": [
+        {
+            "name": "diameter_of_binary_tree",
+            "parameters": "root: TreeNode | None",
+            "return_type": "int",
+            "dummy_return": "0"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom leetcode_py import TreeNode\nfrom .solution import Solution",
+    "test_class_name": "DiameterOfBinaryTree",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_diameter_of_binary_tree",
+            "parametrize": "root_list, expected",
+            "parametrize_typed": "root_list: list[int | None], expected: int",
+            "test_cases": "[([1, 2, 3, 4, 5], 3), ([1, 2], 1)]",
+            "body": "root = TreeNode.from_list(root_list)\nresult = self.solution.diameter_of_binary_tree(root)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution\nfrom leetcode_py import TreeNode",
+    "playground_test_case": "# Example test case\nroot_list: list[int | None] = [1, 2, 3, 4, 5]\nexpected = 3",
+    "playground_execution": "root = TreeNode.from_list(root_list)\nresult = Solution().diameter_of_binary_tree(root)\nresult",
+    "playground_assertion": "assert result == expected"
+}
diff --git a/Makefile b/Makefile
@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= majority_element
+PROBLEM ?= diameter_of_binary_tree
 FORCE ?= 0
 COMMA := ,
 
diff --git a/leetcode/diameter_of_binary_tree/README.md b/leetcode/diameter_of_binary_tree/README.md
@@ -0,0 +1,40 @@
+# Diameter of Binary Tree
+
+**Difficulty:** Easy
+**Topics:** Tree, Depth-First Search, Binary Tree
+**Tags:** grind-75
+
+**LeetCode:** [Problem 543](https://leetcode.com/problems/diameter-of-binary-tree/description/)
+
+## Problem Description
+
+Given the `root` of a binary tree, return the length of the **diameter** of the tree.
+
+The **diameter** of a binary tree is the **length** of the longest path between any two nodes in a tree. This path may or may not pass through the `root`.
+
+The **length** of a path between two nodes is represented by the number of edges between them.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2021/03/06/diamtree.jpg)
+
+```
+Input: root = [1,2,3,4,5]
+Output: 3
+```
+
+**Explanation:** 3 is the length of the path [4,2,1,3] or [5,2,1,3].
+
+### Example 2:
+
+```
+Input: root = [1,2]
+Output: 1
+```
+
+## Constraints
+
+- The number of nodes in the tree is in the range [1, 10^4].
+- -100 <= Node.val <= 100
diff --git a/leetcode/diameter_of_binary_tree/__init__.py b/leetcode/diameter_of_binary_tree/__init__.py
diff --git a/leetcode/diameter_of_binary_tree/playground.ipynb b/leetcode/diameter_of_binary_tree/playground.ipynb
@@ -0,0 +1,171 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution\n",
+    "\n",
+    "from leetcode_py import TreeNode"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "root_list: list[int | None] = [1, 2, 3, 4, 5]\n",
+    "expected = 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "root = TreeNode.from_list(root_list)\n",
+    "result = Solution().diameter_of_binary_tree(root)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "248f3295",
+   "metadata": {},
+   "outputs": [
+    {
+     "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=\"99\" cy=\"-162\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"99\" 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=\"63\" cy=\"-90\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"63\" 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=\"M90.65,-144.76C86.42,-136.55 81.19,-126.37 76.42,-117.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"79.68,-115.79 72,-108.49 73.46,-118.99 79.68,-115.79\"/>\n",
+       "</g>\n",
+       "<!-- 4 -->\n",
+       "<g id=\"node5\" class=\"node\">\n",
+       "<title>4</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"135\" cy=\"-90\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"135\" y=\"-84.95\" font-family=\"Times,serif\" font-size=\"14.00\">3</text>\n",
+       "</g>\n",
+       "<!-- 0&#45;&gt;4 -->\n",
+       "<g id=\"edge4\" class=\"edge\">\n",
+       "<title>0&#45;&gt;4</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M107.35,-144.76C111.58,-136.55 116.81,-126.37 121.58,-117.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"124.54,-118.99 126,-108.49 118.32,-115.79 124.54,-118.99\"/>\n",
+       "</g>\n",
+       "<!-- 2 -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>2</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"27\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"27\" y=\"-12.95\" font-family=\"Times,serif\" font-size=\"14.00\">4</text>\n",
+       "</g>\n",
+       "<!-- 1&#45;&gt;2 -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>1&#45;&gt;2</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M54.65,-72.76C50.42,-64.55 45.19,-54.37 40.42,-45.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"43.68,-43.79 36,-36.49 37.46,-46.99 43.68,-43.79\"/>\n",
+       "</g>\n",
+       "<!-- 3 -->\n",
+       "<g id=\"node4\" class=\"node\">\n",
+       "<title>3</title>\n",
+       "<ellipse fill=\"none\" stroke=\"black\" cx=\"99\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n",
+       "<text xml:space=\"preserve\" text-anchor=\"middle\" x=\"99\" y=\"-12.95\" font-family=\"Times,serif\" font-size=\"14.00\">5</text>\n",
+       "</g>\n",
+       "<!-- 1&#45;&gt;3 -->\n",
+       "<g id=\"edge3\" class=\"edge\">\n",
+       "<title>1&#45;&gt;3</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M71.35,-72.76C75.58,-64.55 80.81,-54.37 85.58,-45.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"88.54,-46.99 90,-36.49 82.32,-43.79 88.54,-46.99\"/>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "TreeNode([1, 2, 3, 4, 5])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "root"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "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/diameter_of_binary_tree/solution.py b/leetcode/diameter_of_binary_tree/solution.py
@@ -0,0 +1,22 @@
+from leetcode_py import TreeNode
+
+
+class Solution:
+    # Time: O(n)
+    # Space: O(h)
+    def diameter_of_binary_tree(self, root: TreeNode | None) -> int:
+        self.max_diameter = 0
+
+        def dfs(node: TreeNode | None) -> int:
+            if not node:
+                return 0
+
+            left = dfs(node.left)
+            right = dfs(node.right)
+
+            self.max_diameter = max(self.max_diameter, left + right)
+
+            return max(left, right) + 1
+
+        dfs(root)
+        return self.max_diameter
diff --git a/leetcode/diameter_of_binary_tree/tests.py b/leetcode/diameter_of_binary_tree/tests.py
@@ -0,0 +1,31 @@
+import pytest
+
+from leetcode_py import TreeNode
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestDiameterOfBinaryTree:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "root_list, expected",
+        [
+            ([1, 2, 3, 4, 5], 3),
+            ([1, 2], 1),
+            ([1], 0),
+            ([], 0),
+            ([1, 2, 3, 4, 5, None, None, 6, 7], 4),
+            ([1, None, 2, None, 3, None, 4], 3),
+            ([1, 2, None, 3, None, 4], 3),
+            ([1, 2, 3], 2),
+            ([1, 2, 3, 4, None, None, 5], 4),
+        ],
+    )
+    @logged_test
+    def test_diameter_of_binary_tree(self, root_list: list[int | None], expected: int):
+        root = TreeNode.from_list(root_list)
+        result = self.solution.diameter_of_binary_tree(root)
+        assert result == expected
