Update readme.md

Co-Authored-By: Antim-IWP <[email protected]>
Co-Authored-By: Shiwangi Srivastava <[email protected]>

Author: 3 people

Solution/236. Lowest Common Ancestor of a Binary Tree/readme.md

@@ -0,0 +1,239 @@
+Sure! Here's the full LeetCode-style `README.md` file for **236. Lowest Common Ancestor of a Binary Tree**, formatted just like in the `doocs/leetcode` GitHub repository.
+
+---
+
+```markdown
+---
+title: "236. Lowest Common Ancestor of a Binary Tree"
+description: "Recursive DFS solution to find the lowest common ancestor of two nodes in a binary tree."
+difficulty: Medium
+tags:
+  - Tree
+  - Depth-First Search
+  - Binary Tree
+---
+
+## Description
+
+Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
+
+According to the [definition of LCA on Wikipedia](https://en.wikipedia.org/wiki/Lowest_common_ancestor):  
+“The lowest common ancestor is defined between two nodes `p` and `q` as the lowest node in `T` that has both `p` and `q` as descendants (where we allow a node to be a descendant of itself).”
+
+### Example 1:
+
+![Example1](https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/images/binarytree.png)
+
+```
+Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+Output: 3
+Explanation: The LCA of nodes 5 and 1 is 3.
+```
+
+### Example 2:
+
+```
+Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+Output: 5
+Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself.
+```
+
+### Example 3:
+
+```
+Input: root = [1,2], p = 1, q = 2
+Output: 1
+```
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [2, 10⁵].
+- -10⁹ <= Node.val <= 10⁹
+- All Node.val are **unique**.
+- `p != q`
+- `p` and `q` will exist in the tree.
+
+---
+
+## Solutions
+
+### Approach: Recursion (DFS)
+
+We recursively search the tree:
+
+- If the current node is `null`, or matches `p` or `q`, return it.
+- Recursively search the left and right subtrees.
+- If both sides return non-null, this node is the LCA.
+- Otherwise, return the non-null result from one of the sides.
+
+**Time Complexity:** O(n)  
+**Space Complexity:** O(n)
+
+---
+
+### Code
+
+#### Python3
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def lowestCommonAncestor(
+        self, root: "TreeNode", p: "TreeNode", q: "TreeNode"
+    ) -> "TreeNode":
+        if root in (None, p, q):
+            return root
+        left = self.lowestCommonAncestor(root.left, p, q)
+        right = self.lowestCommonAncestor(root.right, p, q)
+        return root if left and right else (left or right)
+```
+
+#### Java
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null || root == p || root == q) {
+            return root;
+        }
+        var left = lowestCommonAncestor(root.left, p, q);
+        var right = lowestCommonAncestor(root.right, p, q);
+        if (left != null && right != null) {
+            return root;
+        }
+        return left == null ? right : left;
+    }
+}
+```
+
+#### 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 Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        if (root == nullptr || root == p || root == q) {
+            return root;
+        }
+        auto left = lowestCommonAncestor(root->left, p, q);
+        auto right = lowestCommonAncestor(root->right, p, q);
+        if (left && right) {
+            return root;
+        }
+        return left ? left : right;
+    }
+};
+```
+
+#### Go
+
+```go
+func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
+	if root == nil || root == p || root == q {
+		return root
+	}
+	left := lowestCommonAncestor(root.Left, p, q)
+	right := lowestCommonAncestor(root.Right, p, q)
+	if left != nil && right != nil {
+		return root
+	}
+	if left != nil {
+		return left
+	}
+	return right
+}
+```
+
+#### TypeScript
+
+```ts
+function lowestCommonAncestor(
+    root: TreeNode | null,
+    p: TreeNode | null,
+    q: TreeNode | null,
+): TreeNode | null {
+    if (!root || root === p || root === q) {
+        return root;
+    }
+    const left = lowestCommonAncestor(root.left, p, q);
+    const right = lowestCommonAncestor(root.right, p, q);
+    return left && right ? root : left || right;
+}
+```
+
+#### Rust
+
+```rust
+use std::cell::RefCell;
+use std::rc::Rc;
+impl Solution {
+    pub fn lowest_common_ancestor(
+        root: Option<Rc<RefCell<TreeNode>>>,
+        p: Option<Rc<RefCell<TreeNode>>>,
+        q: Option<Rc<RefCell<TreeNode>>>,
+    ) -> Option<Rc<RefCell<TreeNode>>> {
+        if root.is_none() || root == p || root == q {
+            return root;
+        }
+        let left = Self::lowest_common_ancestor(
+            root.as_ref().unwrap().borrow().left.clone(),
+            p.clone(),
+            q.clone(),
+        );
+        let right = Self::lowest_common_ancestor(
+            root.as_ref().unwrap().borrow().right.clone(),
+            p.clone(),
+            q.clone(),
+        );
+        if left.is_some() && right.is_some() {
+            return root;
+        }
+        if left.is_none() {
+            return right;
+        }
+        return left;
+    }
+}
+```
+
+#### JavaScript
+
+```js
+var lowestCommonAncestor = function (root, p, q) {
+    if (!root || root === p || root === q) {
+        return root;
+    }
+    const left = lowestCommonAncestor(root.left, p, q);
+    const right = lowestCommonAncestor(root.right, p, q);
+    return left && right ? root : left || right;
+};
+```
+
+---
+```
+
+Let me know if you’d like the Chinese version or a version for any other specific language or format!