一、题目描述：

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

1. 示例 1：
   • 输入：head = [1,2,3,4,5], n = 2
   • 输出：[1,2,3,5]
2. 示例 2：
   • 输入：head = [1], n = 1
   • 输出：[]
3. 示例 3：
   • 输入：head = [1,2], n = 1
   • 输出：[1]

• 提示：
  • 链表中结点的数目为 sz
  • $0\le Node.val\le 100$
  • $1\le n\le sz$

二、解决思路和代码

1. 解决思路：借助两个指针实现一趟扫描完成

• 分析：链表的长度是 sz ，删除倒数第 n 个节点，那么链表的长度 $sz\ge n$。怎么找到倒数第 n 个结点呢？
  

  • 删除倒数第n个节点，前面有sz-n个节点。反之，前面有n个节点，那么后面有sz-n个节点。
    • 第一个指针cur：找到从前面数第n个节点
    • 第二个指针pre：找到从前面数第sz-n个节点。则pre.next就是要删除的节点。
  • 其他情况
    • 有一个节点
    • 有两个节点

2. 代码

 from typing import *
 class ListNode:
     def __init__(self, val=0, next=None):
         self.val = val
         self.next = next
         
 class Solution:
     def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
         cur = head
         count = 0
         while cur:
             count+=1
             if count-n < 0: cur = cur.next

             ## 只有一个结点，删除第一个结点（尾结点）
             if count-n==0 and cur.next==None: return head.next  
             if count-n==1:
                 ## 只有两个结点，删除尾结点
                 if cur.next==None:
                     head.next = head.next.next
                     return head
                 else:
                     cur = cur.next
                     pre = head
             if count-n>1:
                 while cur.next:
                     cur = cur.next
                     pre = pre.next  
                 break         
         pre.next = pre.next.next
         return head

 if __name__ == '__main__':
 
     head = [1,2,3,4,5]
     n = 2
     
     lsHead = pre = ListNode(val=-1)
     for i in head:
         cur = ListNode(val=i)
         pre.next = cur
         pre = cur
 
     res = Solution().removeNthFromEnd(lsHead.next, n)
     cur = res
     while cur:
         print(cur.val)
         cur = cur.next
 ```