[ 热题 HOT 100]---19. 删除链表的倒数第N个节点---链表➕双指针

1 题目描述

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

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：

给定的 n 保证是有效的。

进阶：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2 解题思路

解题思路参考之前的博文：https://blog.csdn.net/qq_43584847/article/details/105617506

• 解决方法：双指针

算法流程：

（1）初始化： 前指针 former 、后指针 latter ，双指针都指向头节点 head​ 。
（2）构建双指针距离： 前指针 former 先向前走 k 步**（结束后，双指针 former 和 latter 间相距 k 步）。**
删掉的指针是头节点的情况在这考虑，前指针为空并且后面的结点是headif(former == null && latter == head) return head.next;
（3）双指针共同移动： 前指针不为空并且前指针的next结点不为空时，进行循环，双指针 former 和 latter 每轮都向前走一步，
直至 former 走过链表 尾节点 时跳出**（跳出后， latter 与尾节点距离为 k−1，即 latter 指向倒数第 k 个节点）。**

不同的地方
（4）删除倒数第k个结点，更改latter的next 的指向即可， latter.next = latter.next.next;

（4）返回值： 返回 题目要求的head 即可。

• 复杂度分析：
  时间复杂度 O(N) ： N 为链表长度；总体看， former 走了 N 步， latter 走了 (N−k) 步。
  空间复杂度 O(1) ： 双指针 former , latter 使用常数大小的额外空间。

3 解决代码

• 解决方法：双指针《Java代码》

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null){
            return null;
        }
        ListNode former = head;
        ListNode latter = head;
        // 前面的节点先走k步
        for(int i = 0; i < n; i++){
            former = former.next;
            // 删掉的节点是头节点的情况
            if(former == null && latter == head){
                return head.next;
            }
        }
        //后面的节点两个继续一起走，这样两者相差k
        while(former != null && former.next != null){
            former = former.next;
            latter = latter.next;
        }
        //删掉第k个节点
        latter.next = latter.next.next;
        return head;

    }
}

• 解决方法：双指针《python3代码》

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        former = head
        latter = head
        # 前面的节点先走k步
        for i in range (n):
            former = former.next
            # 删掉的节点是头节点的情况
            if not former and latter == head:
                return head.next
        # 后面的节点两个继续一起走，这样两者相差k
        while former and former.next:
            former = former.next
            latter = latter.next
        # 删掉第k个节点
        latter.next = latter.next.next
        return head