LeetCode 笔记系列四 Remove Nth Node From End of List

题目：Given a linked list, remove the n^th node from the end of list and return its head.For example,

   Given linked list: 1->2->3->4->5, and n = 2.

   After removing the second node from the end, the linked list becomes 1->2->3->5.

就是让你删除单链表倒数第n个节点，同时希望能只遍历一次。

解法一： 如果不遍历完所有节点，怎么知道倒数第n个在哪里呢？但是遍历完成以后，删除不是又需要遍历么？不过删除一个node实际上只需要一个pre node就行了。于是，考虑使用一个HashMap保存遍历过的节点，实现删除。

public ListNode removeNthFromEnd(ListNode head, int n) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(head == null) return null;
        HashMap<Integer, ListNode> map = new HashMap<Integer, ListNode>();
        int i = 0;
        ListNode p = head;
        while(p != null){
            map.put(++i, p);
            p = p.next;
        }
        ListNode pre = map.get(i - n);//i - n is the node that right BEFORE the to-be-deleted node.
        if(pre != null){
            ListNode deleted = pre.next;
            if(deleted != null)
                pre.next = deleted.next;
        }else {//if pre is null, means we are deleting head
            head = head.next;
        }
        return head;
    }

感觉每次做题，如果用到了额外的数据结构或者空间，都有一种开挂的感觉。能不能不显式使用额外的空间或者数据结构呢？想到最近看了Algorithm 4th edtion关于递归删除BST的方法，有一些启发。

解法二： 我们尝试使用递归来解。

public ListNode removeNthFromEnd2(ListNode head, int n) {
        if(head == null) return null;
        int[] counter = new int[]{0};
        return removeNthFromEnd2(head,n,counter);
    }
    
    private static ListNode removeNthFromEnd2(ListNode head, int n, int[] counter){
        if(head.next == null){// we reached tail
            counter[0] = 1;
        }else {
            head.next = removeNthFromEnd2(head.next, n, counter);
            counter[0]++;//we increment this counter to record when we back from the recursive, namely back from the last node
        }
        if(counter[0] == n){//oh, this is nth node backward, we just RETURN THE NEXT NODE.
            return head.next;
        }else return head;//otherwise return whatever we received
    }

是不是看上去很简洁？同样的，我们还是需要遍历完所有节点。但是递归的好处是每次返回的都是“backward"，通过这个特点，我们使用一个counter变量，在递归返回的时候，记录返回经过的节点（Java不如C#，没有ref参数，所以只能用一个数组记录这个counter变量以达到引用的效果）。这样当counter到打n的时候，我们知道，哦，好啦这个当前节点就是我们要删除的节点咯。所以，instead of直接返回head节点，我们返回删除节点的next，这样，在递归调用再次返回的时候，pre的next就指向了删除节点的next咯。

好吧，承认实际上这也是遍历了两次链表。。。：<

解法三： 为了减少遍历，我们还可以用两个指针slow和fast，fast先走n步。then，slow和fast共同进步直到fast走到尾巴。Code在这里。