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]

思路：

设置一个哑节点，它的 next 指针指向链表的头节点。这样，就不需要对头节点进行特殊的判断了。

例如，在本题中，如果我们要删除节点 y，我们需要知道节点 y 的前驱节点 x，并将 x 的指针指向 y 的后继节点。但由于头节点不存在前驱节点，因此我们需要在删除头节点时进行特殊判断。但如果我们添加了哑节点，那么头节点的前驱节点就是哑节点本身，此时我们就只需要考虑通用的情况即可。

1. 遍历两次：第一次遍历确定链表长度L，（设head节点为第一个节点），则第L-n+1个节点为需删除的节点，第L-n个节点为其前驱节点。然后，第二次遍历找到第L-n个节点，并使其next指向第l-n+2个节点。
2. 栈：根据栈的性质，将所有节点入栈，则第n个出栈的节点即为待删除的节点，其出栈后，前驱节点为stack.top()指向的节点,设为temp，则使其next指向temp->next->next的节点即可。
3. 双指针：设置双指针i，j，使j指针比i指针快n步，则j指针指向NULL时，i指针指向待删除节点；若j指针比i指针快n+1步，则j指针指向NULL时，i指针指向待删除节点的前驱节点，此时使其next指向temp->next->next的节点即可。（遍历一次）

（1）C++_1

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* p = new ListNode(0,head);
        ListNode* q = head;
        int l = 0;
        while(q!=nullptr){
            l+=1;
            q = q->next;
        }
        ListNode* temp = p;
        for(int i=0;i<l-n;i++){
            temp = temp->next;
        }
        temp->next=temp->next->next;
        ListNode* res = p->next;
        delete p;
        return res;
    }
};

(2)C++_2

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* p = new ListNode(0,head);
        ListNode* q = p;
        stack<ListNode*> s;
        while(q!=nullptr){
            s.push(q);
            q=q->next;
        }
        for(int i=0;i<n;i++){
            s.pop();
        }
        ListNode* temp = s.top();
        temp->next = temp->next->next;
        ListNode* res = p->next;
        delete p;
        return res;
    }
};

(3)C++_3

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* p = new ListNode(0,head);
        ListNode* i = p;
        ListNode* j = head;
        for(int k=0;k<n;k++){
            j=j->next;
        }
        while(j!=nullptr){
            j=j->next;
            i=i->next;
        }
        i->next = i->next->next;
        ListNode* res = p->next;
        delete p;
        return res;
    }
};

(4)python_1

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        p = ListNode(0,head)
        l=0
        q = head
        while(q!=None):
            l+=1
            q=q.next
        temp = p
        for i in range(l-n):
            temp = temp.next
        temp.next=temp.next.next
        res = p.next
        del p
        return res

(5)python_2

python中可用list实现栈的功能

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        p = ListNode(0,head)
        s=[]
        q = p
        while(q!=None):
            s.append(q)
            q=q.next
        for i in range(n):
            s.pop()
        temp = s[-1]
        temp.next=temp.next.next
        res = p.next
        del p
        return res

(6)python_3

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        p = ListNode(0,head)
        i = p
        j = head
        for k in range(n):
            j = j.next
        while(j!=None):
            j = j.next
            i = i.next
        i.next=i.next.next
        res = p.next
        del p
        return res