feat: update solutions to lc problem: No.0024. Swap Nodes in Pairs

Author: yanglbme

solution/0000-0099/0024.Swap Nodes in Pairs/README.md

@@ -46,11 +46,12 @@
 
 <p><strong>进阶：</strong>你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）</p>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+设置虚拟头节点 dummy，pre 指针初始指向 dummy，遍历链表，每次交换 pre 后面的两个节点即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -72,8 +73,7 @@ class Solution:
             cur.next = t.next
             t.next = cur
             pre.next = t
-            pre = cur
-            cur = pre.next
+            pre, cur = cur, cur.next
         return dummy.next
 ```
 
@@ -102,14 +102,43 @@ class Solution {
             t.next = cur;
             pre.next = t;
             pre = cur;
-            cur = pre.next;
-
+            cur = cur.next;
         }
         return dummy.next;
     }
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var swapPairs = function(head) {
+    const dummy = new ListNode(0, head);
+    let pre = dummy;
+    let cur = head;
+    while (cur && cur.next) {
+        const t = cur.next;
+        cur.next = t.next;
+        t.next = cur;
+        pre.next = t;
+        pre = cur;
+        cur = cur.next;
+    }
+    return dummy.next;
+};
+```
+
 ### **C++**
 
 ```cpp
@@ -126,22 +155,75 @@ class Solution {
 class Solution {
 public:
     ListNode* swapPairs(ListNode* head) {
-        ListNode* dummy = new ListNode(0, head);
-        ListNode* pre = dummy;
-        ListNode* cur = head;
+        ListNode *dummy = new ListNode(0, head);
+        ListNode *pre = dummy, *cur = head;
         while (cur != nullptr && cur->next != nullptr) {
-            ListNode* t = cur->next;
+            ListNode *t = cur->next;
             cur->next = t->next;
             t->next = cur;
             pre->next = t;
             pre = cur;
-            cur = pre->next;
+            cur = cur->next;
         }
         return dummy->next;
     }
 };
 ```
 
+### **Go**
+
+```go
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func swapPairs(head *ListNode) *ListNode {
+    dummy := &ListNode{0, head}
+    pre, cur := dummy, head
+    for cur != nil && cur.Next != nil {
+        t := cur.Next
+        cur.Next = t.Next
+        t.Next = cur
+        pre.Next = t
+        pre = cur
+        cur = cur.Next
+    }
+    return dummy.Next
+}
+```
+
+### **Ruby**
+
+```rb
+# Definition for singly-linked list.
+# class ListNode
+#     attr_accessor :val, :next
+#     def initialize(val = 0, _next = nil)
+#         @val = val
+#         @next = _next
+#     end
+# end
+# @param {ListNode} head
+# @return {ListNode}
+def swap_pairs(head)
+    dummy = ListNode.new(0, head)
+    pre = dummy
+    cur = head
+    while !cur.nil? && !cur.next.nil?
+        t = cur.next
+        cur.next = t.next
+        t.next = cur
+        pre.next = t
+        pre = cur
+        cur = cur.next
+    end
+    dummy.next
+end
+```
+
 ### **...**
 
 ```

solution/0000-0099/0024.Swap Nodes in Pairs/README_EN.md

@@ -60,8 +60,7 @@ class Solution:
             cur.next = t.next
             t.next = cur
             pre.next = t
-            pre = cur
-            cur = pre.next
+            pre, cur = cur, cur.next
         return dummy.next
 ```
 
@@ -88,14 +87,43 @@ class Solution {
             t.next = cur;
             pre.next = t;
             pre = cur;
-            cur = pre.next;
-
+            cur = cur.next;
         }
         return dummy.next;
     }
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var swapPairs = function(head) {
+    const dummy = new ListNode(0, head);
+    let pre = dummy;
+    let cur = head;
+    while (cur && cur.next) {
+        const t = cur.next;
+        cur.next = t.next;
+        t.next = cur;
+        pre.next = t;
+        pre = cur;
+        cur = cur.next;
+    }
+    return dummy.next;
+};
+```
+
 ### **C++**
 
 ```cpp
@@ -112,22 +140,75 @@ class Solution {
 class Solution {
 public:
     ListNode* swapPairs(ListNode* head) {
-        ListNode* dummy = new ListNode(0, head);
-        ListNode* pre = dummy;
-        ListNode* cur = head;
+        ListNode *dummy = new ListNode(0, head);
+        ListNode *pre = dummy, *cur = head;
         while (cur != nullptr && cur->next != nullptr) {
-            ListNode* t = cur->next;
+            ListNode *t = cur->next;
             cur->next = t->next;
             t->next = cur;
             pre->next = t;
             pre = cur;
-            cur = pre->next;
+            cur = cur->next;
         }
         return dummy->next;
     }
 };
 ```
 
+### **Go**
+
+```go
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func swapPairs(head *ListNode) *ListNode {
+    dummy := &ListNode{0, head}
+    pre, cur := dummy, head
+    for cur != nil && cur.Next != nil {
+        t := cur.Next
+        cur.Next = t.Next
+        t.Next = cur
+        pre.Next = t
+        pre = cur
+        cur = cur.Next
+    }
+    return dummy.Next
+}
+```
+
+### **Ruby**
+
+```rb
+# Definition for singly-linked list.
+# class ListNode
+#     attr_accessor :val, :next
+#     def initialize(val = 0, _next = nil)
+#         @val = val
+#         @next = _next
+#     end
+# end
+# @param {ListNode} head
+# @return {ListNode}
+def swap_pairs(head)
+    dummy = ListNode.new(0, head)
+    pre = dummy
+    cur = head
+    while !cur.nil? && !cur.next.nil?
+        t = cur.next
+        cur.next = t.next
+        t.next = cur
+        pre.next = t
+        pre = cur
+        cur = cur.next
+    end
+    dummy.next
+end
+```
+
 ### **...**
 
 ```

solution/0000-0099/0024.Swap Nodes in Pairs/Solution.cpp

@@ -11,16 +11,15 @@
 class Solution {
 public:
     ListNode* swapPairs(ListNode* head) {
-        ListNode* dummy = new ListNode(0, head);
-        ListNode* pre = dummy;
-        ListNode* cur = head;
+        ListNode *dummy = new ListNode(0, head);
+        ListNode *pre = dummy, *cur = head;
         while (cur != nullptr && cur->next != nullptr) {
-            ListNode* t = cur->next;
+            ListNode *t = cur->next;
             cur->next = t->next;
             t->next = cur;
             pre->next = t;
             pre = cur;
-            cur = pre->next;
+            cur = cur->next;
         }
         return dummy->next;
     }

solution/0000-0099/0024.Swap Nodes in Pairs/Solution.go

@@ -6,27 +6,15 @@
  * }
  */
  func swapPairs(head *ListNode) *ListNode {
-	if head == nil || head.Next == nil {
-		return head
-	}
-	first := head
-	second := head.Next
-	r := second
-    var p *ListNode = nil
-	for first != nil && second != nil {
-		t := second.Next
-		second.Next = first
-		first.Next = t
-		if p != nil {
-			p.Next = second
-		}
-        p = first
-        if t != nil {
-			second = t.Next
-		} else {
-			second = nil
-		}
-		first = t
-	}
-	return r
+    dummy := &ListNode{0, head}
+    pre, cur := dummy, head
+    for cur != nil && cur.Next != nil {
+        t := cur.Next
+        cur.Next = t.Next
+        t.Next = cur
+        pre.Next = t
+        pre = cur
+        cur = cur.Next
+    }
+    return dummy.Next
 }

solution/0000-0099/0024.Swap Nodes in Pairs/Solution.java

@@ -18,8 +18,7 @@ public ListNode swapPairs(ListNode head) {
             t.next = cur;
             pre.next = t;
             pre = cur;
-            cur = pre.next;
-
+            cur = cur.next;
         }
         return dummy.next;
     }

solution/0000-0099/0024.Swap Nodes in Pairs/Solution.js

@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+ var swapPairs = function(head) {
+    const dummy = new ListNode(0, head);
+    let pre = dummy;
+    let cur = head;
+    while (cur && cur.next) {
+        const t = cur.next;
+        cur.next = t.next;
+        t.next = cur;
+        pre.next = t;
+        pre = cur;
+        cur = cur.next;
+    }
+    return dummy.next;
+};

solution/0000-0099/0024.Swap Nodes in Pairs/Solution.py

@@ -12,6 +12,5 @@ def swapPairs(self, head: ListNode) -> ListNode:
             cur.next = t.next
             t.next = cur
             pre.next = t
-            pre = cur
-            cur = pre.next
+            pre, cur = cur, cur.next
         return dummy.next