力扣题19删除链表的倒数第N个结点

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

1.比较简单的思路，但是需要两次遍历链表，第一次计算出链表的长度，第二次找到要删除结点的前一个结点(注意单独讨论没有前一个节点存在的情况)。可以定义一个头指针来解决单独讨论删除第一个结点的情况。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int length = 0;
        ListNode pNode = head;
        while(pNode != null){//计算出单向链表的长度
            length++;
            pNode = pNode.next;
        }

        int count = length - n;//

        if(count < 0){//当n超过了单向链表中节点的总个数
            return head;
        }

        if(count == 0){//如果删除的是第一个节点 
            return head.next;
        }

        pNode = head;
        for(;count > 1;count--){//找到要删除的节点的前一个节点
            pNode = pNode.next;
        }

        pNode.next = pNode.next.next;

        return head;
    }
}

2.利用前后两个指针来实现一次遍历。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode first = head;//后指针
        ListNode second = head;//前指针
        for(int i = 0;i < n;i++){//让前指针先向前走n个结点
            second = second.next;
        }

        if(second == null){//此时是要删除的结点是链表的第一个结点
            return first.next;
        }

        while(second.next != null){//前、后指针一起向后移动，前指针移动到尾节点，此时后指针指向的就是要删除结点的前一个结点
            first = first.next;
            second = second.next;
        }

        first.next = first.next.next;
        return head;
    }
}

   可以定义一个头结点，这样就不需要单独讨论删除的是第一个节点的情况了。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);//自己创建一个头结点
        ListNode first = head;//前指针
        ListNode second = dummy;//后指针，指向新创建的头结点
        for (int i = 0; i < n; ++i) {
            first = first.next;
        }
        while (first != null) {
            first = first.next;
            second = second.next;
        }
        second.next = second.next.next;
        ListNode ans = dummy.next;//最后记得去掉自己创建的头结点
        return ans;
    }
}

3.利用栈的思想来解决。遍历一个结点就入栈，然后从栈顶开始去除元素，去除n个栈顶元素后，留下的新的栈顶元素就是要删除的结点的前一个结点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        Deque<ListNode> stack = new LinkedList<ListNode>();
        ListNode cur = dummy;
        while (cur != null) {
            stack.push(cur);//将链表结点全部入栈
            cur = cur.next;
        }
        for (int i = 0; i < n; ++i) {//取出倒数n个结点
            stack.pop();
        }
        ListNode prev = stack.peek();//得到要删除结点的前一个结点
        prev.next = prev.next.next;
        ListNode ans = dummy.next;
        return ans;
    }
}

第二次做到的时候，又想到一种新的方式：定义first和second两个指针，先让second走n步，这样first和second距离就是n，然后一起往后移动两个指针，当senond走到末尾时，first的下一个节点就是要删除的节点。当n等于1时，就是删除最后一个节点，直接将first指向null；如果大于1，那么就将first的下一个节点删除即可。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode newHead = new ListNode(0);
        newHead.next = head;

        ListNode first = newHead;
        ListNode second = newHead;
        for (int i = 0;i < n;i++) {//先让second移动n步
            second = second.next;
        }
        while (second.next != null) {//同时移动first和second，直到second走到末尾
            first = first.next;
            second = second.next;
        }
        if (n == 1) {
            first.next = null;
        } else {
            first.next = first.next.next;
        }
        return newHead.next;
    }
}

题源：力扣