add java solution

Author: billryan

zh-hans/linked_list/remove_nth_node_from_end_of_list.md

@@ -1,88 +1,49 @@
+---
+difficulty: Easy
+tags:
+- Linked List
+- Two Pointers
+title: Remove Nth Node From End of List
+---
+
 # Remove Nth Node From End of List
 
-## Question
+## Problem
 
-- lintcode: [(174) Remove Nth Node From End of List](http://www.lintcode.com/en/problem/remove-nth-node-from-end-of-list/)
+### Metadata
 
-```
-Given a linked list, remove the nth node from the end of list and return its head.
+- tags: Linked List, Two Pointers
+- difficulty: Easy
+- source(lintcode): <https://www.lintcode.com/problem/remove-nth-node-from-end-of-list/>
+- source(leetcode): <https://leetcode.com/problems/remove-nth-node-from-end-of-list/>
 
-Note
-The minimum number of nodes in list is n.
+### Description
 
-Example
-Given linked list: 1->2->3->4->5->null, and n = 2.
+Given a linked list, remove the n<sup>th</sup> node from the end of list and return its head.
 
-After removing the second node from the end, the linked list becomes 1->2->3->5->null.
 
-Challenge
-O(n) time
-```
+#### Notice
 
-## 题解
+The minimum number of nodes in list is *n*.
 
-简单题，
-使用快慢指针解决此题，需要注意最后删除的是否为头节点。让快指针先走`n`步，直至快指针走到终点，找到需要删除节点之前的一个节点，改变`node->next`域即可。
+#### Example
 
-### C++
+Given linked list: `1->2->3->4->5->null`, and *n* = `2`.
 
-```c++
-/**
- * Definition of ListNode
- * class ListNode {
- * public:
- *     int val;
- *     ListNode *next;
- *     ListNode(int val) {
- *         this->val = val;
- *         this->next = NULL;
- *     }
- * }
- */
-class Solution {
-public:
-    /**
-     * @param head: The first node of linked list.
-     * @param n: An integer.
-     * @return: The head of linked list.
-     */
-    ListNode *removeNthFromEnd(ListNode *head, int n) {
-        if (NULL == head || n < 0) {
-            return NULL;
-        }
+After removing the second node from the end, the linked list becomes `1->2->3->5->null`.
 
-        ListNode *preN = head;
-        ListNode *tail = head;
-        // slow fast pointer
-        int index = 0;
-        while (index < n) {
-            if (NULL == tail) {
-                return NULL;
-            }
-            tail = tail->next;
-            ++index;
-        }
 
-        if (NULL == tail) {
-            return head->next;
-        }
+#### Challenge
 
-        while (tail->next) {
-            tail = tail->next;
-            preN = preN->next;
-        }
-        preN->next = preN->next->next;
+Can you do it without getting the length of the linked list?
 
-        return head;
-    }
-};
-```
+## 题解
 
-以上代码单独判断了是否需要删除头节点的情况，在遇到头节点不确定的情况下，引入`dummy`节点将会使代码更加优雅，改进的代码如下。
+简单题，使用快慢指针解决此题，需要注意最后删除的是否为头节点。让快指针先走`n`步，直至快指针走到终点，找到需要删除节点之前的一个节点，改变`node->next`域即可。见基础数据结构部分的链表解析。
 
-### C++ dummy node
+### C++
 
-```c++
+```cpp
 /**
  * Definition of ListNode
  * class ListNode {
@@ -129,6 +90,49 @@ public:
 };
 ```
 
+### Java
+
+```java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        if (head == nul) return head;
+
+        ListNode dummy = new ListNode(0);
+        dummy.next = head;
+        ListNode fast = head;
+        ListNode slow = dummy;
+        for (int i = 0; i < n; i++) {
+            fast = fast.next;
+        }
+
+        while(fast != null) {
+            fast = fast.next;
+            slow = slow.next;
+        }
+
+        // gc friendly
+        // ListNode toBeDeleted = slow.next;
+        slow.next = slow.next.next;
+        // toBeDeleted.next = null;
+        // toBeDeleted = null;
+
+        return dummy.next;
+    }
+}
+```
+
 ### 源码分析
 
-引入`dummy`节点后画个图分析下就能确定`head`和`preDel`的转移关系了。
+引入`dummy`节点后画个图分析下就能确定`head`和`preDel`的转移关系了。 注意 while 循环中和快慢指针初始化的关系，否则容易在顺序上错一。
+
+### 复杂度分析
+
+极限情况下遍历两遍链表，时间复杂度为 $$O(n)$$.