LeetCode

Reverse Linked List II

2013.12.31 16:00

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.

Solution1:

　　Reversing a linked list is typical for a technical interview, but this variation is a bit more diffcult.

　　My solution, is to cut the list into three parts: [1, m - 1], [m, n], [n + 1, end], locate the middle part, reverse it and restore the pointers at last.

　　Time complexity is O(n), space compexity is O(1).

Accepted code:

// 3RE, 1WA, 1AC, so difficult...
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *reverseBetween(ListNode *head, int m, int n) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int i;
        ListNode *p1, *p2;
        ListNode *root, *t1, *t2;
        ListNode *par;
        
        root = new ListNode(0);
        root->next = head;
        p1 = root;
        for(i = 0; i < m - 1; ++i){
            p1 = p1->next;
        }
        // 1RE here, wrong pointer
        par = p1;
        p1 = p1->next;
        
        t1 = nullptr;
        t2 = p1;
        // 1RE here, i < n - m + 1
        for(i = 0; i < n - m + 1; ++i){
            p2 = t2;
            p2 = p2->next;
            t2->next = t1;
            t1 = t2;
            // 1RE here, wrong pointer
            t2 = p2;
        }
        // 1WA, wrong pointer
        par->next = t1;
        p1->next = t2;
        head = root->next;
        
        delete root;
        return head;
    }
};

Solution2:

　　In the solution above, one new operation was called. This overhead can be reduced with some extra code.

　　Always remember that new and delete are expensive operations, especially when they're called unnecessarily or irregularly.

　　Please see the code below. Time complexity is O(n), space complexity is O(1).

Accepted code:

// 1WA, 1AC, faulty operator is extremely difficult to debug, take this lesson!
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *reverseBetween(ListNode *head, int m, int n) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int i;
        ListNode *p1, *p2;
        ListNode *t1, *t2;
        ListNode *par;
        
        // 1WA here, (O_o), != or ==? ...
        if(head == nullptr){
            return head;
        }
        
        if(m > 1){
            p1 = head;
            for(i = 0; i < m - 2; ++i){
                p1 = p1->next;
            }
            par = p1;
            p1 = p1->next;
        }else{
            par = nullptr;
            p1 = head;
        }
        
        t1 = nullptr;
        t2 = p1;
        for(i = 0; i < n - m + 1; ++i){
            p2 = t2->next;
            t2->next = t1;
            t1 = t2;
            t2 = p2;
        }
        if(par != nullptr){
            par->next = t1;
        }else{
            head = t1;
        }
        p1->next = t2;
        
        return head;
    }
};