【leetcode】删除链表的倒数第 N 个结点 c++ python

题目描述：

c++代码：

/**
 * 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* temp=head;
        ListNode* temp2=head;
        ListNode* res=temp2;
        int l=0;
        while(temp!=nullptr){
            l++;
            temp=temp->next;
        }
        if(l==n)return temp2->next; // 删除头节点
        int index=0;
        while(temp2!=nullptr){
            index++;
            if(index==l-n){
                ListNode* behind=temp2->next->next;
                temp2->next=behind;
                break;
            }
            temp2=temp2->next;
        }
        return res;
    }
};

先遍历一遍得到链表总长，再从头遍历一遍找到要删除节点的前一个节点a，把a->next赋值为a->next->next。

注意特殊情况，当要删除的节点为头节点，按照遍历找前一个节点的方法找不到前一个节点a，应当直接返回头节点的下一个节点head->next。

c++代码 只遍历一遍：

/**
 * 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) {
        stack<ListNode*> s;
        ListNode* head2 = new ListNode(-1,head); //新的表头节点，指向head
        ListNode* temp=head2;
        ListNode* res=temp;
        while(temp!=nullptr){//遍历一遍链表，所有节点值入栈
            s.push(temp); 
            temp=temp->next;
        }
        for(int i=0;i<n;i++){ //n-1次出栈
            s.pop();
        }
        ListNode* behind = s.top()->next->next;
        s.top()->next=behind;
        return res->next; //注意返回的时候，返回新表头的后一个节点
    }
};

只遍历一遍：因为要对倒数第n个节点操作，先进后出，使用栈。
使用LiNode*类型的栈，遍历一遍链表，保存链表中的每个节点。
再pop() n次，此时栈顶即为倒数第n个节点的前一个节点，对该节点赋值：

ListNode* behind = s.pop()->next->next;
s.pop()->next = behind;

特殊情况，要删除的是头节点，执行n次pop后，栈为空，此时无法更新赋值。

为解决特殊情况需要一个工具头节点head2，指向原链表头节点，保证节点全部删除时栈不为空，栈内还有工具头节点，可以更新赋值。注意最后返回head2->next。

python代码：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeNthFromEnd(self, head, n):
        head2=ListNode(-1,head);#工具头节点
        left=head2
        right=head
        for i in range(n-1): #right先向右移动n格 后半段长度为n，右移right让left可以从head开始向右移
            right=right.next
        while right.next!=None:#right到达链表尾节点结束
            right=right.next
            left=left.next #因为left的起点比right少一个，所以left到达的是后半段长度为n的节点的前一个节点
        behind=left.next.next
        left.next=behind  #对left赋值，执行删除
        return head2.next
        

双指针法：
注意到最后一段链表长度为n，问题的关键为找到该段链表的前一个节点。

使用两个指针left，right来分别标识该段链表的前一个节点和该段链表的最后一个节点。

因为长度为n，先让right向右移动 n-1 位，使得从头节点head开始到当前right的链表长度有n；
接下来，同时向右移动left和right，直到right到达链表的尾节点，此时left和right即为最后长为n的链表的两个端点。

但为了删除节点，需要left为长为n的链表的前一个节点，即现在得到的left需要向左移动一位，即left比right向右移动的位数少1，只需要让left从头节点head的前一个节点（新建的工具头节点head2）开始，而right正常从head开始即可。

注意补充特殊情况的处理：当left移动完还是head2说明left没有移动，链表的长度为1，直接返回None。

注意：
1.链表问题注意用新头节点记录头节点，防止改变原链表头节点

2.记录新头节点，以在对链表进行变换后返回变换后的链表的头节点

3.对于可能涉及头节点删除插入的变换，需要new一个新的工具头节点head2放在原头节点的前面，最后返回head2->next

4.提取问题的关键，转化问题。如链表中删除节点的关键是找到要删除的节点的前一个节点，以对其next重新赋值。