class Solution {
public:
ListNode* reverseBetween(ListNode* head, int m, int n) {
if (m == n) return head;
auto cur = head;
if (m == 1) {
return reverse(head, n);
}
for (int i = 0; i < m - 2; ++i) {
cur = cur->next;
}
cur->next = reverse(cur->next, n - m + 1);
return head;
}
private:
ListNode* reverse(ListNode *head, int count) {
ListNode *cur = head, *prior = nullptr;
for (int i = 0; i < count; ++i) {
const auto next = cur->next;
cur->next = prior;
prior = cur;
cur = next;
}
head->next = cur;
return prior;
}
};
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head, int length) {
ListNode node = head;
if (node == null || node.next == null) {
return node;
}
ListNode prior = null;
for (int i = 0; i < length; i++) {
ListNode next = node.next;
node.next = prior;
prior = node;
node = next;
}
head.next = node;
return prior;
// 注意这里
}
public ListNode reverseBetween(ListNode head, int m, int n) {
if (m == n) {
return head;
}
ListNode node = head;
if (m == 1) {
return reverseList(head, n);
}
// how many jumps are there if from 1, ending at m - 1 (1)
for (int i = 1; i < m - 1; i++) {
node = node.next;
}
// reverse from m (2) to n (4), n - m + 1 edges/nodes to be reversed
node.next = reverseList(node.next, n - m + 1);
return head;
}
}