从零学算法19

19.给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]

• 我的原始人解法：最容易想到的就是，先得到链表长度，然后遍历到需要删除的结点的前一个结点时，让他指向被删除结点的下一个结点就行，不过如果示例 2 这种删除头结点的就特殊处理一下

•   public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode node = head;
        int len = 0;
        // 得到长度
        while(node != null){
            len++;
            node = node.next;
        }
        node = head;
        int index = 0;
        // 删除头结点
        if(len - n == 0){
            return head.next;
        }
        // 遍历到被删除结点的前一个结点
        while(index < len-n-1){
            node = node.next;
            index++;
        }
        node.next = node.next.next;
        return head;
    }
  

• 题号：19
• • 他人解法：双指针也能用，假设长度为 len，我要删除倒数第 n 个，其实就是删除正数第 len-n+1个，由于我只需要得到被删除的前一个结点，也就是说我只需要走 len-n+1-1 也就是 len-n 步就行，总共 len 步，想要走 len-n 步，那就先走，len-(len-n) 步，剩下的不就是 len-n 步(我要走 3 步，总共 5 步，那就先走 5-3 也就是 2 步，剩下就是 3 步)，所以那就让快指针先走 len-(len-n) 也就是 n 步，然后快慢同时走直到快指针走到头（等于慢指针走了剩下的 l-n 步）。

•   public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode fast = head;
        ListNode slow = head;
        // fast 先移 n 步，
        for (int i = 0; i < n; i++) {
            fast = fast.next;
        }
        // 如果fast为空，说明剩下的步数为 0，也就是说 len-n = 0 => len==n，
        // 倒数第 len 个不就是表示删除的是头结点
        if (fast == null)
            return head.next;
    
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        // 这里最终slow不是倒数第n个节点，他是倒数第n+1个节点，
        // 他的下一个结点是倒数第n个节点,所以删除的是他的下一个结点
        slow.next = slow.next.next;
        return head;
    }
  

• 他人题解2：递归解决，我也只能理解个大概，先理解一下递归求链表长度

•   //求链表的长度
    private int length(ListNode head) {
    	// 遍历到尾结点则开始回溯
        if (head == null)
            return 0;
        // 从尾结点开始往前回溯计算长度，可以代入长度为 2 的链表理解一下，
        // 第一个结点不为 null，所以 return length(head.next) + 1，这时是第二个结点，
        // 也不为 null，继续 return length(head.next) + 1，这时为 null 了，返回 0，
        // 然后回溯到前一个 length(head.next) + 1 也就是 0 + 1 = 1，
        // 这时继续回溯到最开始的 length(head.next) + 1 也就是 1+1 = 2。
        return length(head.next) + 1;
    }
  

• 在这个求长度的基础上，因为长度是倒着数的，所以可以用 pos 来计算长度的同时，表示当前是倒数第几个，如果 pos -1 等于 n，说明到了被删除结点的前一个结点，完成删除。如果

•   public ListNode removeNthFromEnd(ListNode head, int n) {
        int pos = length(head, n);
        // 和上面同理，pos(len) == n说明删除的是头节点
        if (pos == n)
            return head.next;
        return head;
    }
    
    // 逆序计算链表长度
    public int length(ListNode node, int n) {
        if (node == null)
            return 0;
        int pos = length(node.next, n) + 1;
        //获取要删除链表的前一个结点，就可以完成链表的删除
        if (pos - 1 == n )
            node.next = node.next.next;
        return pos;
    }