删除链表中倒数第n个节点

容易 删除链表中倒数第n个节点

28 %

通过

给定一个链表，删除链表中倒数第n个节点，返回链表的头节点。

您在真实的面试中是否遇到过这个题？ 

Yes

样例

给出链表1->2->3->4->5->null和 n = 2.

删除倒数第二个节点之后，这个链表将变成1->2->3->5->null.

注意

链表中的节点个数大于等于n

挑战

O(n)时间复杂度

标签 Expand 

两根指针 链表

---

---

Note:
Given n will always be valid.
Try to do this in one pass.

这里的Note的意思应该就是可以不做特殊处理n值了。不过其实特殊处理也就一句语句。

思路：

快指针和慢指针的概念，先一个指针先走，到了离起点n个节点远的时候，慢指针走，等到快指针走到结尾，那么慢指针走到了需要删除的位置了。

初学者注意：保留慢指针的前置指针，这样才能删除。

注意：特殊处理需要删除头指针的情况，如输入1->2->3->4; n=4，那么需要删除1，这就需要特殊处理了，头指针往前一步就可以了。

[cpp]  view plain copy print ?

1. struct ListNode {  
2.     int val;  
3.     ListNode *next;  
4.     ListNode(int x) : val(x), next(NULL) {}  
5. };  
6.   
7. class Solution {  
8. public:  
9.     ListNode *removeNthFromEnd(ListNode *head, int n)  
10.     {  
11.         ListNode *end = head;  
12.         int i = 0;  
13.         for (; i < n; i++)  
14.         {  
15.             if (end) end = end->next;  
16.             else break;  
17.         }  
18.         if (i != n) return head;  
19.   
20.         findDeletePos(head, head, head, end);  
21.         return head;  
22.   
23.     }  
24.   
25.     void findDeletePos(ListNode *(&head), ListNode *pre, ListNode *cur, ListNode *end)  
26.     {  
27.         while (end)  
28.         {  
29.             end = end->next;  
30.             pre = cur;  
31.             cur = cur->next;  
32.         }  
33.         //注意：删除头指针的时候要做特殊处理  
34.         if (pre == cur)  
35.         {  
36.             head = head->next;  
37.             return;  
38.         }  
39.         pre->next = cur->next;  
40.     }  
41. };  

 

 //2015-1-25 update

[cpp]  view plain copy print ?

1. ListNode *removeNthFromEnd(ListNode *head, int n)  
2.     {  
3.         ListNode dummy(-1);  
4.         dummy.next = head;  
5.         ListNode *pre = &dummy;  
6.   
7.         while (--n > 0) head = head->next;  
8.   
9.         while (head->next)  
10.         {  
11.             pre = pre->next;  
12.             head = head->next;  
13.         }  
14.         pre->next = pre->next->next;  
15.         return dummy.next;  
16.     }