Merge branch 'main' into main

Author: samarthswami1016

solution/0100-0199/0195.Tenth Line/README_EN.md

@@ -23,41 +23,26 @@ tags:
 <p>Assume that <code>file.txt</code> has the following content:</p>
 
 <pre>
-
 Line 1
-
 Line 2
-
 Line 3
-
 Line 4
-
 Line 5
-
 Line 6
-
 Line 7
-
 Line 8
-
 Line 9
-
 Line 10
-
 </pre>
 
 <p>Your script should output the tenth line, which is:</p>
 
 <pre>
-
 Line 10
-
 </pre>
 
 <div class="spoilers"><b>Note:</b><br />
-
 1. If the file contains less than 10 lines, what should you output?<br />
-
 2. There&#39;s at least three different solutions. Try to explore all possibilities.</div>
 
 <!-- description:end -->

solution/0200-0299/0206.Reverse Linked List/README.md

@@ -67,9 +67,9 @@ tags:
 
 ### 方法一：头插法
 
-创建虚拟头节点 $dummy$，遍历链表，将每个节点依次插入 $dummy$ 的下一个节点。遍历结束，返回 $dummy.next$。
+我们创建一个虚拟头节点 $\textit{dummy}$，然后遍历链表，将每个节点依次插入 $\textit{dummy}$ 的下一个节点。遍历结束，返回 $\textit{dummy.next}$。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为链表的长度。
+时间复杂度 $O(n)$，其中 $n$ 为链表的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -279,15 +279,15 @@ var reverseList = function (head) {
  */
 public class Solution {
     public ListNode ReverseList(ListNode head) {
-        ListNode pre = null;
-        for (ListNode p = head; p != null;)
-        {
-            ListNode t = p.next;
-            p.next = pre;
-            pre = p;
-            p = t;
+        ListNode dummy = new ListNode();
+        ListNode curr = head;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = dummy.next;
+            dummy.next = curr;
+            curr = next;
         }
-        return pre;
+        return dummy.next;
     }
 }
 ```
@@ -466,6 +466,33 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode ans = ReverseList(head.next);
+        head.next.next = head;
+        head.next = null;
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0200-0299/0206.Reverse Linked List/README_EN.md

@@ -58,7 +58,11 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Head Insertion Method
+
+We create a dummy node $\textit{dummy}$, then traverse the linked list and insert each node after the $\textit{dummy}$ node. After traversal, return $\textit{dummy.next}$.
+
+The time complexity is $O(n)$, where $n$ is the length of the linked list. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -268,15 +272,15 @@ var reverseList = function (head) {
  */
 public class Solution {
     public ListNode ReverseList(ListNode head) {
-        ListNode pre = null;
-        for (ListNode p = head; p != null;)
-        {
-            ListNode t = p.next;
-            p.next = pre;
-            pre = p;
-            p = t;
+        ListNode dummy = new ListNode();
+        ListNode curr = head;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = dummy.next;
+            dummy.next = curr;
+            curr = next;
         }
-        return pre;
+        return dummy.next;
     }
 }
 ```
@@ -287,7 +291,11 @@ public class Solution {
 
 <!-- solution:start -->
 
-### Solution 2
+### Solution 2: Recursion
+
+We recursively reverse all nodes from the second node to the end of the list, then attach the $head$ to the end of the reversed list.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the linked list.
 
 <!-- tabs:start -->
 
@@ -451,6 +459,33 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode ans = ReverseList(head.next);
+        head.next.next = head;
+        head.next = null;
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0200-0299/0206.Reverse Linked List/Solution.cs

@@ -11,14 +11,14 @@
  */
 public class Solution {
     public ListNode ReverseList(ListNode head) {
-        ListNode pre = null;
-        for (ListNode p = head; p != null;)
-        {
-            ListNode t = p.next;
-            p.next = pre;
-            pre = p;
-            p = t;
+        ListNode dummy = new ListNode();
+        ListNode curr = head;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = dummy.next;
+            dummy.next = curr;
+            curr = next;
         }
-        return pre;
+        return dummy.next;
     }
-}
+}

solution/0200-0299/0206.Reverse Linked List/Solution2.cs

@@ -0,0 +1,22 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseList(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+        ListNode ans = ReverseList(head.next);
+        head.next.next = head;
+        head.next = null;
+        return ans;
+    }
+}

solution/0200-0299/0234.Palindrome Linked List/README.md

@@ -60,7 +60,7 @@ tags:
 
 我们可以先用快慢指针找到链表的中点，接着反转右半部分的链表。然后同时遍历前后两段链表，若前后两段链表节点对应的值不等，说明不是回文链表，否则说明是回文链表。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为链表的长度。
+时间复杂度 $O(n)$，其中 $n$ 为链表的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/0200-0299/0234.Palindrome Linked List/README_EN.md

@@ -53,7 +53,11 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Fast and Slow Pointers
+
+We can use fast and slow pointers to find the middle of the linked list, then reverse the right half of the list. After that, we traverse both halves simultaneously, checking if the corresponding node values are equal. If any pair of values is unequal, it's not a palindrome linked list; otherwise, it is a palindrome linked list.
+
+The time complexity is $O(n)$, where $n$ is the length of the linked list. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/0200-0299/0235.Lowest Common Ancestor of a Binary Search Tree/README.md

@@ -57,15 +57,11 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一：迭代或递归
+### 方法一：迭代
 
-从上到下搜索，找到第一个值位于 $[p.val, q.val]$ 之间的结点即可。
+我们从根节点开始遍历，如果当前节点的值小于 $\textit{p}$ 和 $\textit{q}$ 的值，说明 $\textit{p}$ 和 $\textit{q}$ 应该在当前节点的右子树，因此将当前节点移动到右子节点；如果当前节点的值大于 $\textit{p}$ 和 $\textit{q}$ 的值，说明 $\textit{p}$ 和 $\textit{q}$ 应该在当前节点的左子树，因此将当前节点移动到左子节点；否则说明当前节点就是 $\textit{p}$ 和 $\textit{q}$ 的最近公共祖先，返回当前节点即可。
 
-既可以用迭代实现，也可以用递归实现。
-
-迭代的时间复杂度为 $O(n)$，空间复杂度为 $O(1)$。
-
-递归的时间复杂度为 $O(n)$，空间复杂度为 $O(n)$。
+时间复杂度 $O(n)$，其中 $n$ 是二叉搜索树的节点个数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -164,9 +160,9 @@ public:
 
 func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {
 	for {
-		if root.Val < p.Val && root.Val < q.Val {
+		if root.Val < min(p.Val, q.Val) {
 			root = root.Right
-		} else if root.Val > p.Val && root.Val > q.Val {
+		} else if root.Val > max(p.Val, q.Val) {
 			root = root.Left
 		} else {
 			return root
@@ -209,13 +205,47 @@ function lowestCommonAncestor(
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        while (true) {
+            if (root.val < Math.Min(p.val, q.val)) {
+                root = root.right;
+            } else if (root.val > Math.Max(p.val, q.val)) {
+                root = root.left;
+            } else {
+                return root;
+            }
+        }
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
 
 <!-- solution:start -->
 
-### 方法二
+### 方法二：递归
+
+我们也可以使用递归的方法来解决这个问题。
+
+我们首先判断当前节点的值是否小于 $\textit{p}$ 和 $\textit{q}$ 的值，如果是，则递归遍历右子树；如果当前节点的值大于 $\textit{p}$ 和 $\textit{q}$ 的值，如果是，则递归遍历左子树；否则说明当前节点就是 $\textit{p}$ 和 $\textit{q}$ 的最近公共祖先，返回当前节点即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉搜索树的节点个数。
 
 <!-- tabs:start -->
 
@@ -339,12 +369,42 @@ function lowestCommonAncestor(
     p: TreeNode | null,
     q: TreeNode | null,
 ): TreeNode | null {
-    if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
-    if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+    if (root.val > p.val && root.val > q.val) {
+        return lowestCommonAncestor(root.left, p, q);
+    }
+    if (root.val < p.val && root.val < q.val) {
+        return lowestCommonAncestor(root.right, p, q);
+    }
     return root;
 }
 ```
 
+#### C#
+
+```cs
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class Solution {
+    public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val < Math.Min(p.val, q.val)) {
+            return LowestCommonAncestor(root.right, p, q);
+        }
+        if (root.val > Math.Max(p.val, q.val)) {
+            return LowestCommonAncestor(root.left, p, q);
+        }
+        return root;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->