19. Remove Nth Node From End of List（删除链表倒数的第N个结点）

题目描述

Given a linked list, remove the n-th node from the end of list and return its head.

Example:

Given linked list: 1->2->3->4->5, and n = 2.

After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:

Given n will always be valid.

Follow up:

Could you do this in one pass?

方法思路

Approach 1: Two pass algorithm

class Solution {
    //Runtime: 5 ms, faster than 100.00%
    //Memory Usage: 37.8 MB, less than 81.74% 
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode test = head, cur = head, pre = null;
        int length = 0;
        while(test != null){
            test = test.next;
            length++;
        }
        int count = length - n + 1;
        while(count != 1){
            pre = cur;
            cur = cur.next;
            count--;
        }
        // used to simplify some corner cases such as
   	 	// a list with only one node, or removing the head of the list.    
        if(pre == null)
            return head.next;
        pre.next = cur.next;
        return head;
    }
}

上下两个代码是同一思路的不同实现，区别不大。

class Solution{
    public ListNode removeNthFromEnd(ListNode head, int n) {
    //The "dummy" node is used to simplify some corner cases such as
    // a list with only one node, or removing the head of the list.    
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    int length  = 0;
    ListNode first = head;
    while (first != null) {
        length++;
        first = first.next;
    }
    length -= n;
    first = dummy;
    while (length > 0) {
        length--;
        first = first.next;
    }
    first.next = first.next.next;
    return dummy.next;
    }
}

Approach 2: One pass algorithm

Algorithm

The above algorithm could be optimized to one pass. Instead of one pointer, we could use two pointers. The first pointer advances the list by n+1 steps from the beginning, while the second pointer starts from the beginning of the list. Now, both pointers are exactly separated by nnn nodes apart. We maintain this constant gap by advancing both pointers together until the first pointer arrives past the last node. The second pointer will be pointing at the nnnth node counting from the last. We relink the next pointer of the node referenced by the second pointer to point to the node’s next next node.:

 class Solution{
    //Runtime: 5 ms, faster than 100.00% 
    public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode first = dummy;
    ListNode second = dummy;
    // Advances first pointer so that the gap between first and second is n nodes apart
    for (int i = 1; i <= n + 1; i++) {
        first = first.next;
    }
    // Move first to the end, maintaining the gap
    while (first != null) {
        first = first.next;
        second = second.next;
    }
    second.next = second.next.next;
    return dummy.next;
    }
}