【LeetCode刷题记录】19. 删除链表的倒数第 N 个结点

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

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

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：
输入：head = [1], n = 1
输出：[]

示例 3：
输入：head = [1,2], n = 1
输出：[1]

提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

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

思路（法二、法三参考力扣官方题解）

链表解题经典三板斧，哑巴节点，栈，快慢指针。
PS：哑结点dummy

ListNode* dummy = new ListNode(0, head);

哑节点是指向原来头节点的一个节点，数据域通常无意义。
程序开头开辟一块空间声明这个哑结点（哑结点指向链表开头），最后返回dummy->next。
没有哑结点需要单独考虑头结点的情况，如法一。
（1）计算链表长度
先扫描一遍整个链表，记录链表长度len，再扫描第二遍，用len-n标记要删除的链表元素，注意对删除头结点进行特殊处理，否则访问 pre->next 就会导致空指针解引用错误。
（2）栈
利用栈后进先出的特点。先将链表元素全部入栈，再利用栈后进先出的特点，出掉最后n个元素，此时栈顶元素即为要删除元素的前一位，更改其next指向为删除元素后一位即可。
（3）快慢指针
设置快慢指针fast，slow，fast始终与slow相差n个元素，这样fast遍历到链表末端时，slow恰好在倒数第n个元素的前一个，更改其next指向为删除元素后一位即可。

代码

法一：

/**
 * 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* p = head;
        int len = 0;
        while (p != nullptr) {
            len++;
            p = p->next;
        }
        p = head;
        int i = 0;
        ListNode* pre = nullptr;
        while (p != nullptr) {
            if (i == len - n) {
                if (pre == nullptr) {
                    // 删除第一个节点，直接将head等于下一个节点
                    head = p->next;
                } else {
                    pre->next = p->next;
                }
                delete (p);
                break;
            }
            pre = p;
            p = p->next;
            i++;
        }
        return head;
    }
};

法二：

// 栈
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        stack<ListNode*> stk;
        ListNode* dummy = new ListNode(0, head);
        ListNode* p =dummy;
        while(p!=nullptr){
            stk.push(p);
            p=p->next;
        }
        //栈元素后进先出，出掉后n个元素
        for(int i=0;i<n;i++){
            stk.pop();
        }
        // 栈顶元素即为需删除元素的前一位
        ListNode* prev = stk.top();
        prev->next = prev->next->next;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

法三：

// 快慢指针
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0, head);
        // 设置快慢指针，fast与slow之间差n个
        ListNode *fast = head, *slow = dummy;
        for (int i = 0; i < n; i++) {
            fast = fast->next;
        }
        // 这样fast遍历到末节点时，slow恰好在要删除的节点前一个
        while (fast != nullptr) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        ListNode* ans = dummy->next;
        delete dummy;
        return ans;
    }
};