feat: add solutions to lc problem: No.0206

No.0206.Reverse Linked List

Author: yanglbme

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

@@ -50,11 +50,13 @@
 
 ## 解法
 
-定义指针 `p`、`q` 分别指向头节点和下一个节点，`pre` 指向头节点的前一个节点。
+**方法一：头插法**
 
-遍历链表，改变指针 `p` 指向的节点的指向，将其指向 `pre` 指针指向的节点，即 `p.next = pre`。然后 `pre` 指针指向 `p`，`p`、`q` 指针往前走。
+创建虚拟头节点 $dummy$，遍历链表，将每个节点依次插入 $dummy$ 的下一个节点。遍历结束，返回 $dummy.next$。
 
-当遍历结束后，返回 `pre` 指针即可。
+**方法二：递归**
+
+递归反转链表的第二个节点到尾部的所有节点，然后 head 插在反转后的链表的尾部。
 
 <!-- tabs:start -->
 
@@ -63,21 +65,35 @@
 ```python
 # Definition for singly-linked list.
 # class ListNode:
-#     def __init__(self, x):
-#         self.val = x
-#         self.next = None
-
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
 class Solution:
     def reverseList(self, head: ListNode) -> ListNode:
-        previous, current, next = None, head, None
-
-        while current is not None:
-            next = current.next
-            current.next = previous
-            previous = current
-            current = next
+        dummy = ListNode()
+        curr = head
+        while curr:
+            next = curr.next
+            curr.next = dummy.next
+            dummy.next = curr
+            curr = next
+        return dummy.next
+```
 
-        return previous
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reverseList(self, head: ListNode) -> ListNode:
+        if head is None or head.next is None:
+            return head
+        ans = self.reverseList(head.next)
+        head.next.next = head
+        head.next = None
+        return ans
 ```
 
 ### **Java**
@@ -90,19 +106,22 @@ class Solution:
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
     public ListNode reverseList(ListNode head) {
-        ListNode pre = null, p = head;
-        while (p != null) {
-            ListNode q = p.next;
-            p.next = pre;
-            pre = p;
-            p = q;
+        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;
     }
 }
 ```
@@ -115,18 +134,20 @@ class Solution {
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 class Solution {
     public ListNode reverseList(ListNode head) {
         if (head == null || head.next == null) {
             return head;
         }
-        ListNode res = reverseList(head.next);
+        ListNode ans = reverseList(head.next);
         head.next.next = head;
         head.next = null;
-        return res;
+        return ans;
     }
 }
 ```
@@ -146,14 +167,15 @@ class Solution {
  * @return {ListNode}
  */
 var reverseList = function (head) {
-    let pre = null;
-    for (let p = head; p; ) {
-        let q = p.next;
-        p.next = pre;
-        pre = p;
-        p = q;
+    let dummy = new ListNode();
+    let curr = head;
+    while (curr) {
+        let next = curr.next;
+        curr.next = dummy.next;
+        dummy.next = curr;
+        curr = next;
     }
-    return pre;
+    return dummy.next;
 };
 ```
 
@@ -168,14 +190,34 @@ var reverseList = function (head) {
  * }
  */
 func reverseList(head *ListNode) *ListNode {
-	var pre *ListNode
-	for p := head; p != nil; {
-		q := p.Next
-		p.Next = pre
-		pre = p
-		p = q
+	dummy := &ListNode{}
+	curr := head
+	for curr != nil {
+		next := curr.Next
+		curr.Next = dummy.Next
+		dummy.Next = curr
+		curr = next
 	}
-	return pre
+	return dummy.Next
+}
+```
+
+```go
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func reverseList(head *ListNode) *ListNode {
+	if head == nil || head.Next == nil {
+		return head
+	}
+	ans := reverseList(head.Next)
+	head.Next.Next = head
+	head.Next = nil
+	return ans
 }
 ```
 
@@ -195,16 +237,39 @@ func reverseList(head *ListNode) *ListNode {
 class Solution {
 public:
     ListNode* reverseList(ListNode* head) {
-        ListNode* pre = nullptr;
-        ListNode* p = head;
-        while (p)
+        ListNode* dummy = new ListNode();
+        ListNode* curr = head;
+        while (curr)
         {
-            ListNode* q = p->next;
-            p->next = pre;
-            pre = p;
-            p = q;
+            ListNode* next = curr->next;
+            curr->next = dummy->next;
+            dummy->next = curr;
+            curr = next;
         }
-        return pre;
+        return dummy->next;
+    }
+};
+```
+
+```cpp
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* reverseList(ListNode* head) {
+        if (!head || !head->next) return head;
+        ListNode* ans = reverseList(head->next);
+        head->next->next = head;
+        head->next = nullptr;
+        return ans;
     }
 };
 ```