LeetCode 1721. Swapping Nodes in a Linked List

原题链接在这里：https://leetcode.com/problems/swapping-nodes-in-a-linked-list/

题目：

You are given the head of a linked list, and an integer k.

Return the head of the linked list after swapping the values of the kth node from the beginning and the kth node from the end (the list is 1-indexed).

Example 1:

Input: head = [1,2,3,4,5], k = 2
Output: [1,4,3,2,5]

Example 2:

Input: head = [7,9,6,6,7,8,3,0,9,5], k = 5
Output: [7,9,6,6,8,7,3,0,9,5]

Constraints:

The number of nodes in the list is n.
1 <= k <= n <= 105
0 <= Node.val <= 100

题解：

Move the runner k times, and have a mark. This is the kth node from the beginning.

Now move both walker and runner until runner == null. Now walker is the kth ndoe from the end.

Note: check k is larger than list length.

Time Complexity: O(n). n is the length of list.

Space: O(1).

AC Java:

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     int val;
 5  *     ListNode next;
 6  *     ListNode() {}
 7  *     ListNode(int val) { this.val = val; }
 8  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 9  * }
10  */
11 class Solution {
12     public ListNode swapNodes(ListNode head, int k) {
13         if(head == null){
14             return head;
15         }
16         
17         ListNode dummy = new ListNode(-1);
18         dummy.next = head;
19         ListNode runner = dummy;
20         ListNode walker = dummy;
21         while(runner.next != null && k > 0){
22             runner = runner.next;
23             k--;
24         }
25         
26         if(k > 0){
27             return head;
28         }
29         
30         ListNode mark = runner;
31         while(runner != null){
32             runner = runner.next;
33             walker = walker.next;
34         }
35         
36         int temp = walker.val;
37         walker.val = mark.val;
38         mark.val = temp;
39         return dummy.next;
40     }
41 }

AC C++:

 1 /**
 2  * Definition for singly-linked list.
 3  * struct ListNode {
 4  *     int val;
 5  *     ListNode *next;
 6  *     ListNode() : val(0), next(nullptr) {}
 7  *     ListNode(int x) : val(x), next(nullptr) {}
 8  *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 9  * };
10  */
11 class Solution {
12 public:
13     ListNode* swapNodes(ListNode* head, int k) {
14         if(!head || k <= 0){
15             return head;
16         }
17 
18         ListNode* dummy = new ListNode(-1, head);
19         ListNode* walker = dummy;
20         ListNode* runner = dummy;
21         while(k > 0 && runner->next){
22             runner = runner->next;
23             k--;
24         }
25 
26         if(k > 0){
27             return head;
28         }
29 
30         ListNode* marker = runner;
31         while(runner){
32             walker = walker->next;
33             runner = runner->next;
34         }
35 
36         int temp = marker->val;
37         marker->val = walker->val;
38         walker->val = temp;
39         return dummy->next;
40     }
41 };

AC Python:

 1 # Definition for singly-linked list.
 2 # class ListNode:
 3 #     def __init__(self, val=0, next=None):
 4 #         self.val = val
 5 #         self.next = next
 6 class Solution:
 7     def swapNodes(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
 8         if not head or k <= 0:
 9             return head
10         
11         dummy = ListNode(-1, head)
12         walker = runner = dummy
13         while k > 0 and runner.next:
14             runner = runner.next
15             k -= 1
16         
17         if k > 0:
18             return head
19         
20         marker = runner
21         while runner:
22             walker = walker.next
23             runner = runner.next
24         
25         marker.val, walker.val = walker.val, marker.val
26         return dummy.next
27