LeetCode算法题：删除链表的倒数第N个节点

题目描述如下：

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

示例：

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

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

说明：

给定的 n 保证是有效的。

       这道题暴力法的思路很简单，即遍历两遍链表，第一遍统计出链表的节点数（设为L），那么倒数第n个节点就是整数第L-n+1个节点，第二遍遍历删除目标节点。下面给出暴力法的C++代码和python代码。

C++：

/**
 * 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 number = 0;
        ListNode *p;
        p = head;
        while(p!=NULL){
            number += 1;
            p = p->next;
        }
        int flag = number - n;
        number = 1;
        p = head;
        while(p!=NULL){
            if(flag==0){
                head = head->next;
                break;
            }
            if(number==flag){
                p->next = (p->next)->next;
                break;
            }
            number++;
            p = p->next;
        }
        return head;
    }
};

执行结果：

执行用时 : 12 ms, 在Remove Nth Node From End of List的C++提交中击败了96.74% 的用户
内存消耗 : 8.3 MB, 在Remove Nth Node From End of List的C++提交中击败了96.71% 的用户

Python代码如下：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        p = ListNode(None)
        p = head
        number = 0
        while p!=None:
            number += 1
            p = p.next
        flag = number - n
        number = 1
        p = head
        while p!=None:
            if flag==0:
                head = head.next
                break
            elif number==flag:
                p.next = (p.next).next
                break
            p = p.next
            number += 1
        return head

执行结果：

执行用时 : 80 ms, 在Remove Nth Node From End of List的Python3提交中击败了24.74% 的用户
内存消耗 : 13.2 MB, 在Remove Nth Node From End of List的Python3提交中击败了54.23% 的用户

这道题的进阶做法是只遍历一遍链表，用到的方法是快慢指针法，这里给出官方题解的描述：

       上述算法可以优化为只使用一次遍历。我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动 n+1n+1 步，而第二个指针将从列表的开头出发。现在，这两个指针被 n 个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔，直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第 nn 个结点。我们重新链接第二个指针所引用的结点的 next 指针指向该结点的下下个结点。

        这种算法如果用C++写的话会出现错误，因为如果链表只有一个节点或两个节点（删除倒数第二个，即正数第一个节点），快指针会出现空指针的现象，程序会报错。但是java是没有问题的，如果有朋友对java感兴趣，可以看一下官方的题解，看一下代码思路。