92. Reverse Linked List II（链表部分反转）

Reverse a linked list from position m to n. Do it in-place and in one-pass.

For example:
Given 1->2->3->4->5->NULL, m = 2 and n = 4,

return 1->4->3->2->5->NULL.

Note:
Given m, n satisfy the following condition:
1 ≤ m ≤ n ≤ length of list.

 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        def reverse(a,b):
            if a == b:
                return a
            pre = None
            cur = a
            while cur!=b:
                c_next = cur.next
                cur.next = pre
                pre = cur
                cur = c_next
            return pre
        
        fake = ListNode(-1,head)
        a = fake
        for i in range(left-1):
            a = a.next
        b = head
        for i in range(right-1):
            b = b.next
        b_next = b.next
        a.next = reverse(a.next,b.next)
        cur = fake
        while cur and cur.next:
            cur = cur.next
        cur.next = b_next
        return fake.next

 

 

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr) return head;
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while(cur != nullptr) {
            ListNode* c_next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = c_next;
        }
        return pre;
    }
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if(head == nullptr || head->next == nullptr) return head;
        ListNode* fakehead  = new ListNode(0);
        fakehead->next = head;

        ListNode* pre = fakehead;
        ListNode* cur = head;
        ListNode* right_node = head;

        //遍历找到左节点 pre 跟右节点
        int cnt = 1;
        while(cur!=nullptr) {
            if(cnt==left-1) {
                pre = cur;
            }
            if (cnt == right) {
                right_node = cur;
            }
            cur = cur->next;
            cnt++;
        }

        ListNode* left_node = pre->next;
        ListNode* c_next = right_node->next;
        right_node->next = nullptr;
        pre->next = reverseList(left_node);
        left_node->next = c_next;
        return fakehead->next;
    }
};

 

 

 

 

class Solution {
   public ListNode reverseBetween(ListNode head, int m, int n) {
        if(head == null) return head;
        ListNode fakehead = new ListNode(0);
        fakehead.next = head;
        ListNode pre  = fakehead;
        
       
        for (int i = 0; i < m-1;i++) pre = pre.next;
        
        ListNode start = pre.next;
        ListNode then = start.next;
        
        for(int i = 0 ;i < n -m ;i++){
            start.next= then.next;
            then.next = pre.next;
            pre.next = then;
            then=start.next;
        }
    return fakehead.next;
    }
}