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

这个题解答的比较顺利，思路就是先数清楚链表节点个数，然后判断删除的是正数第几个节点，按照正常的链表节点删除方法删除就可以。

如果直接令 deleteList =head 那么需要加判断条件：当删除的是第一个节点时怎么办；

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

如果设定哑结点就不用判断删除的是第一个节点的问题了，第二段代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int count= 0;
        ListNode *printList = head;
        while(printList)
        {
            count++;
            printList = printList->next;
        }
        int deleteNum = count-n+1;
        ListNode *deleteList = new ListNode;
        deleteList->next = head;
        ListNode*tempList = deleteList;
        for(int i = 0;i<deleteNum-1;i++)
        {
            tempList= tempList->next;
        }
        if(tempList->next!=NULL)
        {
            tempList->next = tempList->next->next;
        }
        return deleteList->next;
    }
};

这道题也可以用快慢指针来做，快指针先走完n--大于0，之后快慢指针一块走，快指针走到NULL就是慢指针要删除的点的前一个点，代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummyNode = new ListNode;
        dummyNode->next = head;
        ListNode *fast = dummyNode;
        ListNode *slow = dummyNode;
        while(n>0)
        {
            fast = fast->next;
            n--;
        }
        while(fast->next!=NULL)
        {
            slow = slow->next;
            fast = fast->next;
        }
        slow->next = slow->next->next;
        return dummyNode->next;
    }
};