19. 删除链表的倒数第N个节点 双指针一遍扫描

19. 删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

解法：

很自然的想到先遍历一遍整个链表，统计有多少个节点，从而知道倒数第n个节点顺数是第几个，最后再从头遍历到被删除节点前一个位置，进行删除操作。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int num=0;
        ListNode * p=head;
        while(p->next!=NULL){
            p=p->next;
            num++;
        }
        ListNode* m=head;
        if(n==num+1)
            return head->next;
        for(int i=0;i<num-n;i++){
            m=m->next;
        }
        ListNode * cur=m->next;
        m->next=cur->next;
        return head;
    }
};

进阶：只扫描一遍的话，又要确定倒数第n个节点的位置，可以借助双指针，一个快指针，一个慢指针，让快指针先走n步，然后快慢指针再一起向前，等到快指针走到最后节点处，慢指针刚好走到被删除节点前一个位置。需要注意的是，如果要删除节点是第一个节点，这种情况下快指针走n步后会变成空指针。需要加个判断条件，如果为空，直接返回第二个节点即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int num=0;
        ListNode * p=head;
        for(int i=0;i<n;i++){
            p=p->next;
        }
        if(p==NULL)return head->next;
        ListNode * l=head;
        while(p->next!=NULL){
            p=p->next;
            l=l->next;
        }
        l->next=l->next->next;
        return head;
    }
};

当然为了不需要考虑特殊情况，我们可以加一个附加头结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int num=0;
        ListNode* first=new ListNode(0);
        first->next=head;
        ListNode * p=first;
        for(int i=0;i<n;i++){
            p=p->next;
        }
        ListNode * l=first;
        while(p->next!=NULL){
            p=p->next;
            l=l->next;
        }
        l->next=l->next->next;
        return first->next;
    }
};

此外，还看到有人用空间换时间，在第一次遍历时，用一个数组存储节点，这样也可以直接定位到被删除节点。

总之，这题又让我意识到双指针的厉害之处。

之前在求三数之和、四数之和时用左右指针加快遍历，减少一层循环，适合在已经排好序的数组。现在用快慢指针进行快速定位。