一、🌱19. 删除链表的倒数第 N 个结点

题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
来源：力扣（LeetCode）
难度：中等
提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
示例 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]

🌴解题

我们要删除指定节点，就是找到该节点的前驱节点 pre，将其后继节点改为需要删除节点的后继节点（不考虑节点释放情况，或者添加一个指向删除节点的指针进行释放操作）。而删除的节点可能就是头结点，不存在 pre，为了方便处理我们通常会在前面添加一个哑节点 dummy，最后返回的也就是 dummy 的后继节点。

1.双指针

我们如何确定是不是倒第 N 个数节点，采用双指针就是先让一个指针先走 N 步，然后同步遍历链表走到有个指针为空的时候。
把 fast 指针位于哑节点最后遍历结束就是位于被删除节点的前驱节点上，删除之后返回返回哑节点的后继节点即可。
在这里插入图片描述

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode fastNode=head,slowNode=new ListNode();
        slowNode.next=head;
        head=slowNode;
        for(int i=0;i<n;i++){
            fastNode=fastNode.next;
        }
        while(fastNode!=null){
            fastNode=fastNode.next;
            slowNode=slowNode.next;
        }
        // delect slowNode `s next Node
        if(slowNode.next!=null) {
            slowNode.next = slowNode.next.next;
        }else{
            slowNode.next=null;
        }
        return head.next;
    }
}

在这里插入图片描述

2.栈

这个方法也很好理解，栈是先进后出，节点全部进栈之后出栈，出栈 N 个节点，此时栈顶元素就是第 N 个节点的前驱节点。

class Solution19 {
    public static ListNode19 removeNthFromEnd(ListNode19 head, int n) {
        ListNode19 dummy = new ListNode19(0, head);
        Deque<ListNode19> nodeStack = new LinkedList<ListNode19>();
        ListNode19 cur = dummy;
        while (cur != null) {//全部入栈
            nodeStack.push(cur);
            cur = cur.next;
        }
        for (int i = 0; i < n; ++i) {//出栈n个节点，后n
            nodeStack.pop();
        }
        ListNode19 prev = nodeStack.peek();//get 倒数第n个前一个
        prev.next = prev.next.next;

        return dummy.next;
    }
}

在这里插入图片描述

🌵 君不见，黄河之水天上来，奔流到海不复回。 — 李白

返回第一页。☝

☕物有本末，事有终始，知所先后。🍭

🍎☝☝☝☝☝我的CSDN☝☝☝☝☝☝🍓

附完整代码：

package code;

import java.util.Deque;
import java.util.LinkedList;

public class c19 {
    public static void main(String[] args) {
        int[] nums={1};
        int n=1;
        //creat ListNode
        ListNode19 head=new ListNode19(nums[0]);
        ListNode19 q=head;
        for (int i = 1; i < nums.length; i++) {
            ListNode19 p=new ListNode19(nums[i]);
            q.next=p;
            q=p;
        }

        q=Solution19.removeNthFromEnd(head,n);
        while (q!=null){
            System.out.print(q.val+" ——> ");
            q=q.next;
        }
        System.out.println("end");

    }
}
class ListNode19{
    int val;
    ListNode19 next;
    public ListNode19() {
    }
    public ListNode19(int val) {
        this.val = val;
    }
    public ListNode19(int val, ListNode19 nextNode) {
        this.val = val;
        this.next = nextNode;
    }
}
/*
//双指针
class Solution19 {
    public static ListNode19 removeNthFromEnd(ListNode19 head, int n) {
        ListNode19 fastNode=head,slowNode=new ListNode19();
        slowNode.next=head;
        head=slowNode;
        for(int i=0;i<n;i++){
            fastNode=fastNode.next;
        }
        while(fastNode!=null){
            fastNode=fastNode.next;
            slowNode=slowNode.next;
        }
        // delect slowNode `s next Node
        if(slowNode.next!=null) {
            slowNode.next = slowNode.next.next;
        }else{
            slowNode.next=null;
        }
        return head.next;
    }
}*/

//栈
class Solution19 {
    public static ListNode19 removeNthFromEnd(ListNode19 head, int n) {
        ListNode19 dummy = new ListNode19(0, head);
        Deque<ListNode19> nodeStack = new LinkedList<ListNode19>();
        ListNode19 cur = dummy;
        while (cur != null) {//全部入栈
            nodeStack.push(cur);
            cur = cur.next;
        }
        for (int i = 0; i < n; ++i) {//出栈n个节点，后n
            nodeStack.pop();
        }
        ListNode19 prev = nodeStack.peek();//get 倒数第n个前一个
        prev.next = prev.next.next;

        return dummy.next;
    }
}