面试经典算法系列之链表7 -- 删除链表的倒数第N个结点

面试经典算法13-删除链表的倒数第N个结点

LeetCode.19
公众号：阿Q技术站

问题描述

给你一个链表，删除链表的倒数第 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

思路

1. 使用双指针 slow 和 fast，初始时都指向链表的头节点。
2. 让 fast 指针先向前移动 n 步，使得 fast 指针与 slow 指针之间相差 n 个节点。
3. 接着，同时移动 fast 和 slow 指针，直到 fast 指针指向链表的末尾节点。此时，slow 指针就指向了倒数第 n 个节点的前一个节点。
4. 最后，删除倒数第 n 个节点，即将 slow 的下一个节点指向下下个节点即可。

此方法耗时挺短。

图解

根据示例一进行图解。

1. 使用双指针 slow 和 fast，初始时都指向链表的头节点。

2. 让 fast 指针先向前移动 n 步，使得 fast 指针与 slow 指针之间相差 n 个节点。这里n=2

3. 同时移动 fast 和 slow 指针，直到 fast 指针指向链表的末尾节点。此时，slow 指针就指向了倒数第 n 个节点的前一个节点。

4. 删除倒数第 n 个节点，即将 slow 的下一个节点指向下下个节点即可。

5. 最后，删除虚拟头结点，返回新的头结点即可。

参考代码

C++

#include <iostream>

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0); // 创建一个虚拟头节点，用于处理删除头节点的情况
        dummy->next = head;
        ListNode* slow = dummy;
        ListNode* fast = dummy;

        // 让 fast 先向前移动 n 步
        for (int i = 0; i <= n; ++i) {
            fast = fast->next;
        }

        // 同时移动 fast 和 slow，直到 fast 指向链表末尾的 nullptr
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }

        // 删除倒数第 n 个节点
        slow->next = slow->next->next;

        ListNode* newHead = dummy->next; // 获取新的头节点
        delete dummy; // 删除虚拟头节点
        return newHead;
    }
};

// 创建链表
ListNode* createList(std::vector<int>& nums) {
    if (nums.empty()) return nullptr;
    ListNode* head = new ListNode(nums[0]);
    ListNode* cur = head;
    for (int i = 1; i < nums.size(); ++i) {
        cur->next = new ListNode(nums[i]);
        cur = cur->next;
    }
    return head;
}

// 输出链表
void printList(ListNode* head) {
    ListNode* cur = head;
    while (cur) {
        std::cout << cur->val << " ";
        cur = cur->next;
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    ListNode* head = createList(nums);
    int n = 2;

    Solution solution;
    head = solution.removeNthFromEnd(head, n);

    printList(head); // 输出删除倒数第 n 个节点后的链表

    return 0;
}

Java

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0); // 创建虚拟头节点
        dummy.next = head;
        ListNode fast = dummy;
        ListNode slow = dummy;

        // 让 fast 先向前移动 n 步
        for (int i = 0; i <= n; i++) {
            fast = fast.next;
        }

        // 同时移动 fast 和 slow，直到 fast 指向链表末尾的 null
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }

        // 删除倒数第 n 个节点
        slow.next = slow.next.next;

        return dummy.next; // 返回头节点的下一个节点
    }

    // 创建链表
    public static ListNode createList(int[] nums) {
        if (nums == null || nums.length == 0) return null;
        ListNode head = new ListNode(nums[0]);
        ListNode cur = head;
        for (int i = 1; i < nums.length; i++) {
            cur.next = new ListNode(nums[i]);
            cur = cur.next;
        }
        return head;
    }

    // 输出链表
    public static void printList(ListNode head) {
        ListNode cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        ListNode head = createList(nums);
        int n = 2;

        Solution solution = new Solution();
        head = solution.removeNthFromEnd(head, n);

        printList(head); // 输出删除倒数第 n 个节点后的链表
    }
}

Python

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy = ListNode(0)  # 创建虚拟头节点
        dummy.next = head
        fast = dummy
        slow = dummy

        # 让 fast 先向前移动 n 步
        for _ in range(n + 1):
            fast = fast.next

        # 同时移动 fast 和 slow，直到 fast 指向链表末尾的 None
        while fast is not None:
            fast = fast.next
            slow = slow.next

        # 删除倒数第 n 个节点
        slow.next = slow.next.next

        return dummy.next  # 返回头节点的下一个节点

    # 创建链表
    def createList(self, nums):
        if not nums:
            return None
        head = ListNode(nums[0])
        cur = head
        for num in nums[1:]:
            cur.next = ListNode(num)
            cur = cur.next
        return head

    # 输出链表
    def printList(self, head):
        cur = head
        while cur is not None:
            print(cur.val, end=" ")
            cur = cur.next
        print()

nums = [1, 2, 3, 4, 5]
n = 2

solution = Solution()
head = solution.createList(nums)
head = solution.removeNthFromEnd(head, n)
solution.printList(head)  # 输出删除倒数第 n 个节点后的链表