017-leetcode-删除链表中倒数第N个节点

package linkedlist;

/**
 * 删除链表的倒数第N个节点
 * 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
 * <p>
 * 进阶：你能尝试使用一趟扫描实现吗？
 * <p>
 * 示例 1：
 * <p>
 * <p>
 * 输入：head = [1,2,3,4,5], n = 2
 * 输出：[1,2,3,5]
 * 示例 2：
 * <p>
 * 输入：head = [1], n = 1
 * 输出：[]
 * 示例 3：
 * <p>
 * 输入：head = [1,2], n = 1
 * 输出：[1]
 *  
 * <p>
 * 提示：
 * <p>
 * 链表中结点的数目为 sz
 * 1 <= sz <= 30
 * 0 <= Node.val <= 100
 * 1 <= n <= sz
 * <p>
 * 作者：力扣 (LeetCode)
 * 链接：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/xn2925/
 * 来源：力扣（LeetCode）
 * 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
 */
public class RemoveNthFromEnd {

    private static class ListNode {
        private int val;
        private ListNode next;

        ListNode(int val) {
            this.val = val;
        }

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

    }

    public static void main(String[] args) {
       ListNode node5 = new ListNode(5);
       ListNode node4 = new ListNode(4, node5);
       ListNode node3 = new ListNode(3, node4);
       ListNode node2 = new ListNode(2, node3);
       ListNode node1 = new ListNode(1, node2);
       ListNode head  = removeNthFromEnd(node1, 5);
       while (head.next!=null){
           System.out.println("val "+head.val);
           head = head.next;
       }
        System.out.println("val "+head.val);
    }

    // [1, 2 ,3, 4, 5] n=2  ===> 1 2 3 5
    //1. 如果pKNode的next是null, 则停止循环，说明pNode的下一个节点就是要被删除的节点，然后将 pNode的next指向pNode.next.next
    //2. 如何返回头结点？头结点一般不动 除非我们要删除的是倒数第5个节点，就是动了头结点 将 head指向 head.next 即 head = head.next
    private static ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode pNode = head;
        ListNode pKNode = head;
        while (n > 0) {
            pKNode = pKNode.next;
            n--;
        }
        //pkNode == null 表示要删除的是倒数最后一个，即正数第一个数字
        //那么就需要将 head 节点指向它的下一个节点(正数第二个节点)，即head = head.next;
        //此时，因为要返回头结点，所以就 return head; 
        if (pKNode == null){
            head = head.next;
            return head;
        }
        while (pKNode.next != null) {
            pNode  = pNode.next;
            pKNode = pKNode.next;
        }
        assert pNode.next != null;
        pNode.next = pNode.next.next;
        return head;
    }

    //  1       2      3
    // pHead
    //        pHead    pHead
    //  pHead = p1 pHead.next = null
    //  pHead = p2 pHead.next = p1
    //  pHead = p3 pHead.next = p2

    // 翻转链表
    private static void check() {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        node1.next = node2;
        node2.next = node3;

        ListNode pHead = node1;
        pHead.next = null;
        pHead = node2;
        pHead.next = node1;
        pHead = node3;
        pHead.next = node2;

        while (pHead.next != null) {
            System.out.println(" val " + pHead.val);
            pHead = pHead.next;
        }
        System.out.println(" val " + pHead.val);
    }

}

输出如下：

val 2
val 3
val 4
val 5

思路：这里的思路和走步数类似，都是使用双指帧来处理，一个指帧先走N步，然后两个指针再开始同时运动，如果走在前面的指针的 next 遇到Null，则说明走到链表的尽头了，从尽头倒数 N 步，恰好就是走的慢的指针所在的位置，剩下的就可以慢慢思考就可以获取到答案了。