19.删除倒数第n个节点

挺容易一道题，方法在代码注释里。

找到一年前自己拿java写的3种方法，一起贴在这里。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
 //本题是删除倒数第二个节点，目前首先想到的思路是快慢指针，当快指针的next指向为空时候，慢指针刚好为要删除的节点。
 //或者快慢指针才设置的时候相差为3，快指针为空，慢指针就找到要删除的点，删除点为next的后继。
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* slow = dummyhead;
        ListNode* fast = dummyhead;
        while(n-- && fast != nullptr ){
            fast = fast->next;
        }
        //快指针移动n+1步，因为只有这样，fast 和 slow 才能同时移动，slow才能指向删除节点的上一个节点。
        //这样方便删除时的指向操作。
        fast = fast->next;
        while(fast != nullptr){
            fast = fast->next;
            slow = slow->next;
        }
        //此时找到对应的位置，开始删除操作。
        slow->next = slow->next->next;
        return dummyhead->next;
    }
};

java双指针方法实现，和上面的类似。

/**
 * 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 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;
}
}

java 用栈，出栈的倒数第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){
        stack.pop();
    }
    ListNode prev=stack.peek();
    prev.next=prev.next.next;
    ListNode ans=dummy.next;
    return ans;
}
}

java 先获取长度，然后在第二遍遍历时候获取，获取倒数第n+1个，然后倒数第n+1直接指向下一个，输出结果。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy=new ListNode(0,head);
    int length=getLength(head);
    ListNode cur=dummy;
    for(int i=1;i<length-n+1;++i){
        cur=cur.next;
    }
    cur.next=cur.next.next;
    ListNode ans=dummy.next;
    return ans;
    }
    public int getLength(ListNode head) {
        int length = 0;
        while (head != null) {
            ++length;
            head = head.next;
        }
        return length;
    }
}