[LeetCode] Remove Nth Node From End of List

This is a classic problem of linked list. You may solve it using two pointers. The tricky part lies in the head pointer may also be the one that is required to be removed. Handle this carefully.

class Solution {
public:
    ListNode *removeNthFromEnd(ListNode *head, int n) {
        ListNode *pre, *cur;
        pre = cur = head;
        int i = 0;
        for(; i < n; i++)
            cur = cur -> next;
        if(!cur) return head -> next;
        while(cur -> next) {
            pre = pre -> next;
            cur = cur -> next;
        }
        pre -> next = pre -> next -> next;
        return head;
    }
};

You may create a dummy that points to head to facilitate the removal.

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy -> next = head;
        ListNode* pre = dummy;
        ListNode* cur = dummy;
        for (int i = 0; i < n; i++)
            cur = cur -> next;
        while (cur -> next) {
            pre = pre -> next;
            cur = cur -> next;
        }
        ListNode* del = pre -> next;
        pre -> next = del -> next;
        delete del;
        return dummy -> next;
    }
};

This link has a much shorter solution using pointers to pointers, which is a little difficult to understand. The code is rewritten below.

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode** pre = &head;
        ListNode* cur = head;
        for (int i = 1; i < n; i++)
            cur = cur -> next;
        while (cur -> next) {
            pre = &((*pre) -> next);
            cur = cur -> next;
        }
        *pre = (*pre) -> next;
        return head;
    }
};

There is also a recursive solution to this problem in the answers in the above link. 

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        return countRemove(head, n) == 0 ? head -> next : head;
    }
private:
    int countRemove(ListNode* node, int n) {
        if (!(node -> next)) return n - 1;
        int rest = countRemove(node -> next, n);
        if (!rest) node -> next = node -> next -> next;
        return rest - 1;
    }
};