feat: update solutions to lcof problems

Author: yanglbme

lcof/面试题21. 调整数组顺序使奇数位于偶数前面/README.md

@@ -19,41 +19,51 @@
 
 ## 解法
 
+双指针。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
 class Solution:
     def exchange(self, nums: List[int]) -> List[int]:
-        res = [0 for _ in range(len(nums))]
         p, q = 0, len(nums) - 1
-        for e in nums:
-            if (e & 1) == 0:
-                res[q] = e
-                q -= 1
-            else:
-                res[p] = e
+        while p < q:
+            if nums[p] & 1 == 1:
                 p += 1
-        return res
+                continue
+            if nums[q] & 1 == 0:
+                q -= 1
+                continue
+            nums[p], nums[q] = nums[q], nums[p]
+        return nums
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public int[] exchange(int[] nums) {
-        int len = nums.length;
-        int[] res = new int[len];
-        int p = 0, q = len - 1;
-        for (int e : nums) {
-            if ((e & 1) == 0) {
-                res[q--] = e;
-            } else {
-                res[p++] = e;
+        int p = 0, q = nums.length - 1;
+        while (p < q) {
+            if ((nums[p] & 1) == 1) {
+                ++p;
+                continue;
             }
+            if ((nums[q] & 1) == 0) {
+                --q;
+                continue;
+            }
+            swap(nums, p, q);
         }
-        return res;
+        return nums;
+    }
+
+    private void swap(int[] nums, int p, int q) {
+        int t = nums[p];
+        nums[p] = nums[q];
+        nums[q] = t;
     }
 }
 ```

lcof/面试题21. 调整数组顺序使奇数位于偶数前面/Solution.java

@@ -1,15 +1,23 @@
 class Solution {
     public int[] exchange(int[] nums) {
-        int len = nums.length;
-        int[] res = new int[len];
-        int p = 0, q = len - 1;
-        for (int e : nums) {
-            if ((e & 1) == 0) {
-                res[q--] = e;
-            } else {
-                res[p++] = e;
+        int p = 0, q = nums.length - 1;
+        while (p < q) {
+            if ((nums[p] & 1) == 1) {
+                ++p;
+                continue;
             }
+            if ((nums[q] & 1) == 0) {
+                --q;
+                continue;
+            }
+            swap(nums, p, q);
         }
-        return res;
+        return nums;
+    }
+
+    private void swap(int[] nums, int p, int q) {
+        int t = nums[p];
+        nums[p] = nums[q];
+        nums[q] = t;
     }
 }

lcof/面试题21. 调整数组顺序使奇数位于偶数前面/Solution.py

@@ -1,12 +1,12 @@
 class Solution:
     def exchange(self, nums: List[int]) -> List[int]:
-        res = [0 for _ in range(len(nums))]
         p, q = 0, len(nums) - 1
-        for e in nums:
-            if (e & 1) == 0:
-                res[q] = e
-                q -= 1
-            else:
-                res[p] = e
+        while p < q:
+            if nums[p] & 1 == 1:
                 p += 1
-        return res
+                continue
+            if nums[q] & 1 == 0:
+                q -= 1
+                continue
+            nums[p], nums[q] = nums[q], nums[p]
+        return nums

lcof/面试题22. 链表中倒数第k个节点/README.md

@@ -12,9 +12,9 @@
 
 ## 解法
 
-定义 `p`、`q` 指针指向 `head`。
+定义快慢指针 `slow`、`fast`，初始指向 `head`。
 
-`p` 先向前走 `k` 步，接着 `p`、`q` 同时向前走，当 `p` 指向 `null` 时，`q` 指向的节点即为链表的倒数第 `k` 个节点。
+`fast` 先向前走 `k` 步，接着 `slow`、`fast` 同时向前走，当 `fast` 指向 `null` 时，`slow` 指向的节点即为链表的倒数第 `k` 个节点。
 
 <!-- tabs:start -->
 
@@ -29,17 +29,13 @@
 
 class Solution:
     def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
-        if not (head or head.next):
-            return head
-
-        p = q = head
+        slow = fast = head
         for _ in range(k):
-            p = p.next
-        while p:
-            p = p.next
-            q = q.next
-        return q
-
+            fast = fast.next
+        while fast:
+            slow = slow.next
+            fast = fast.next
+        return slow
 ```
 
 ### **Java**
@@ -55,18 +51,15 @@ class Solution:
  */
 class Solution {
     public ListNode getKthFromEnd(ListNode head, int k) {
-        if (head == null || head.next == null) {
-            return head;
-        }
-        ListNode p = head, q = head;
+        ListNode slow = head, fast = head;
         while (k-- > 0) {
-            p = p.next;
+            fast = fast.next;
         }
-        while (p != null) {
-            p = p.next;
-            q = q.next;
+        while (fast != null) {
+            slow = slow.next;
+            fast = fast.next;
         }
-        return q;
+        return slow;
     }
 }
 ```

lcof/面试题22. 链表中倒数第k个节点/Solution.java

@@ -8,17 +8,14 @@
  */
 class Solution {
     public ListNode getKthFromEnd(ListNode head, int k) {
-        if (head == null || head.next == null) {
-            return head;
-        }
-        ListNode p = head, q = head;
+        ListNode slow = head, fast = head;
         while (k-- > 0) {
-            p = p.next;
+            fast = fast.next;
         }
-        while (p != null) {
-            p = p.next;
-            q = q.next;
+        while (fast != null) {
+            slow = slow.next;
+            fast = fast.next;
         }
-        return q;
+        return slow;
     }
 }

lcof/面试题22. 链表中倒数第k个节点/Solution.py

@@ -6,13 +6,10 @@
 
 class Solution:
     def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
-        if not (head or head.next):
-            return head
-        
-        p = q = head
+        slow = fast = head
         for _ in range(k):
-            p = p.next
-        while p:
-            p = p.next
-            q = q.next
-        return q
+            fast = fast.next
+        while fast:
+            slow = slow.next
+            fast = fast.next
+        return slow

lcof/面试题24. 反转链表/README.md

@@ -17,9 +17,9 @@
 
 ## 解法
 
-定义指针 `p`、`q` 分别指向头节点和下一个节点，`pre` 指向头节点的前一个节点。
+定义指针 `pre`，`cur` 分别指向 null 和头节点。
 
-遍历链表，改变指针 `p` 指向的节点的指向，将其指向 `pre` 指针指向的节点，即 `p.next = pre`。然后 `pre` 指针指向 `p`，`p`、`q` 指针往前走。
+遍历链表，将 `cur.next` 临时保存到 `t` 中，然后改变指针 `cur` 指向的节点的指向，将其指向 `pre` 指针指向的节点，即 `cur.next = pre`。然后 `pre` 指针指向 `cur`，`cur` 指针往前走。
 
 当遍历结束后，返回 `pre` 指针即可。
 
@@ -36,12 +36,12 @@
 
 class Solution:
     def reverseList(self, head: ListNode) -> ListNode:
-        pre, p = None, head
-        while p:
-            q = p.next
-            p.next = pre
-            pre = p
-            p = q
+        pre, cur = None, head
+        while cur:
+            t = cur.next
+            cur.next = pre
+            pre = cur
+            cur = t
         return pre
 ```
 
@@ -58,13 +58,12 @@ class Solution:
  */
 class Solution {
     public ListNode reverseList(ListNode head) {
-        ListNode pre = null;
-        ListNode p = head;
-        while (p != null) {
-            ListNode q = p.next;
-            p.next = pre;
-            pre = p;
-            p = q;
+        ListNode pre = null, cur = head;
+        while (cur != null) {
+            ListNode t = cur.next;
+            cur.next = pre;
+            pre = cur;
+            cur = t;
         }
         return pre;
     }

lcof/面试题24. 反转链表/Solution.java

@@ -8,13 +8,12 @@
  */
 class Solution {
     public ListNode reverseList(ListNode head) {
-        ListNode pre = null;
-        ListNode p = head;
-        while (p != null) {
-            ListNode q = p.next;
-            p.next = pre;
-            pre = p;
-            p = q;
+        ListNode pre = null, cur = head;
+        while (cur != null) {
+            ListNode t = cur.next;
+            cur.next = pre;
+            pre = cur;
+            cur = t;
         }
         return pre;
     }

lcof/面试题24. 反转链表/Solution.py

@@ -6,10 +6,10 @@
 
 class Solution:
     def reverseList(self, head: ListNode) -> ListNode:
-        pre, p = None, head
-        while p:
-            q = p.next
-            p.next = pre
-            pre = p
-            p = q
+        pre, cur = None, head
+        while cur:
+            t = cur.next
+            cur.next = pre
+            pre = cur
+            cur = t
         return pre

lcof/面试题25. 合并两个排序的链表/README.md

@@ -32,17 +32,17 @@
 
 class Solution:
     def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
-        dummy = ListNode()
-        cur = dummy
+        dummy = ListNode(0)
+        p = dummy
         while l1 and l2:
             if l1.val <= l2.val:
-                cur.next = l1
+                p.next = l1
                 l1 = l1.next
             else:
-                cur.next = l2
+                p.next = l2
                 l2 = l2.next
-            cur = cur.next
-        cur.next = l1 or l2
+            p = p.next
+        p.next = l1 or l2
         return dummy.next
 ```
 
@@ -60,18 +60,18 @@ class Solution:
 class Solution {
     public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
         ListNode dummy = new ListNode(0);
-        ListNode cur = dummy;
+        ListNode p = dummy;
         while (l1 != null && l2 != null) {
             if (l1.val <= l2.val) {
-                cur.next = l1;
+                p.next = l1;
                 l1 = l1.next;
             } else {
-                cur.next = l2;
+                p.next = l2;
                 l2 = l2.next;
             }
-            cur = cur.next;
+            p = p.next;
         }
-        cur.next = l1 == null ? l2 : l1;
+        p.next = l1 == null ? l2 : l1;
         return dummy.next;
     }
 }

lcof/面试题25. 合并两个排序的链表/Solution.java

@@ -9,18 +9,18 @@
 class Solution {
     public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
         ListNode dummy = new ListNode(0);
-        ListNode cur = dummy;
+        ListNode p = dummy;
         while (l1 != null && l2 != null) {
             if (l1.val <= l2.val) {
-                cur.next = l1;
+                p.next = l1;
                 l1 = l1.next;
             } else {
-                cur.next = l2;
+                p.next = l2;
                 l2 = l2.next;
             }
-            cur = cur.next;
+            p = p.next;
         }
-        cur.next = l1 == null ? l2 : l1;
+        p.next = l1 == null ? l2 : l1;
         return dummy.next;
     }
 }