删除链表的倒数第 N 个节点

题意

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

难度

中等

示例

示例 1：

输入：head = [1,2,3,4,5], n = 2

输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1

输出：[]

输入：head = [1,2], n = 1

输出：[1]

分析

看到这道题，其实很容易想到LinkedList的 remove 方法，对吧？知道 remove 方法是如何实现的，就能写出这道题的题解。

其实现方式也非常简单，先遍历找到对应的节点，通过 node 方法实现，内核用的是 for 循环。

找到节点后，将节点的前一个节点的 next 指向节点的下一个节点；将节点的下一个节点的 prev 指向节点的前一个节点，这样就将节点从链表中删除了。

LeetCode 这道题是单向链表，下面是 LeetCode 为我们定义的链表 ListNode。

class ListNode {
	int val;
	ListNode next;
	ListNode() {}
	ListNode(int val) { this.val = val; }
	ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

两个属性，分别存储当前节点的值，和下一节点的引用。三个构造方法，无参构造、只有值得构造、值和下一节点都有得构造方法。

单向链表的结构就相对简单，只有 next 没有 prev。

第一步，遍历链表，找出链表的长度，确定要删除的节点的位置。

int length = 0;
ListNode current = head;
while (current != null) {
	length++;
	current = current.next;
}

// 找到要删除节点的前一个节点
int index = length - n;

注意是倒数第 n 个节点，所以要用链表的长度减去 n。倒数第 4 个节点的前一个节点就是 5-4=1，也就是第一个节点。

第二步，遍历链表，找到要删除节点的前一个节点。

为了方便删除节点，我们需要一个虚拟节点，让虚拟节点的 next 指向 head，这样就能保证删除节点的前一个节点不为空。

ListNode dummy = new ListNode(0);

dummy.next = head;

为什么？

因为当需要删除的是头节点时，操作与删除中间节点略有不同，因为没有前一个节点可以引用。引入虚拟头节点后，删除头节点和其他节点的操作可以统一处理，因为头节点也会有一个前节点（即虚拟头节点）。

当增加了虚拟节点后，要删除节点的前一个节点就是 index。

current = dummy;
for (int i = 0; i < index; i++) {
	current = current.next;
}

第三步，找到节点后删除。

current.next=current.next.next;

也就是把要删除节点的前一个节点（current）的 next 指向要删除节点（current.next）的下一个节点（current.next.next）。

第四步，返回虚拟节点的 next。

 

return dummy.next;

OK，来看完整的题解：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 创建一个虚拟头节点，简化边界条件处理
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        
        // 第一次遍历，计算链表的总长度
        int length = 0;
        ListNode current = head;
        while (current != null) {
            length++;
            current = current.next;
        }
        
        // 设置长度为到达要删除的节点的前一个节点
        int index = length - n;
        current = dummy;
        // 第二次遍历，找到要删除的节点的前一个节点
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        
        // 删除节点，即跳过要删除的节点
        current.next = current.next.next;
        
        return dummy.next;
    }
}

很不错，如果还不理解的话，那么可以 debug 一下 ACM 模式的代码，看看每一步的执行过程。

public class RemoveNthFromEnd {

    public static void main(String[] args) {

        RemoveNthFromEnd solution = new RemoveNthFromEnd();

        listNode head = new listNode(1, new listNode(2, new listNode(3, new listNode(4, new listNode(5)))));
        listNode ans = solution.removeNthFromEnd(head, 4);
        System.out.println(ans);

    }

    public  listNode removeNthFromEnd( listNode head , int n ){
        //定义一个虚拟节点，方便删除
        listNode dummy =  new listNode(0);
        dummy.next = head;
        //第一次遍历是算链表长度，所以不指向虚拟节点
        //遍历链表，找到链表的长度
        int length = 0;
        listNode cuurn  = head;
        while (cuurn!= null){
            cuurn = cuurn.next;
            length++;
        }
        int index = length-n;
        //遍历链表，找到要删除节点的前一个节点 ，第二次遍历，
        // 用到虚拟节点是因为需要找到要删除节点的前一个结点，方便删除第一个节点。
        cuurn = dummy;
        for (int i = 0; i < index; i++) {
            cuurn = cuurn.next;
        }
        //找到删除节点的前一个结点之后
        //删除节点
        cuurn.next = cuurn.next.next;
        //返回头节点，在虚拟节点的下一个节点
        return  dummy.next;
    }




    static class  listNode{

        //节点两个属性
        private  int val;
        private  listNode next;

        public listNode() {
        }

        public listNode(int val) {
            this.val = val;
        }

        public listNode(int val, listNode next) {
            this.val = val;
            this.next = next;
        }
    }

}

总结

链表是除了数组之外，我们接触到的另外一个数据结构，对于它的增删改查，我们必须得了如指掌，因为这俩数据结构是计算机用来存储数据单元的最基本的容器之二。