如何在O(1)的时间里删除单链表的结点

题目是这样的：给你一个单链表的表头，再给你其中某个结点的指针，要你删除这个结点，条件是你的程序必须在O(1)的时间内完成删除。

由于有的同学对链表还不是很熟悉，本文尽量描述的通俗易懂，老鸟请直接跳过前面一大段。

链表结构如下：

[cpp] view plaincopyprint?

1. struct node
2. {
3. int val;
4. node* next;
5. };

题目不是很难，很快就能想到好办法：)

首先回顾一下普通的删除方法，首先通过表头，找到待删除结点（设为B）的前一个结点（设为A），将A的指向改一下就行，然后删除掉B结点就行了。要删除的结点一定要delete掉，这不仅是个好习惯，而且能避免将来项目中可能造成的内存泄露的严重问题。

[cpp] view plaincopyprint?

1. void DeleteNode_On(node *LinkList, node *p)
2. {
3. printf("delete:%d\n", p->val);
4. node *s = LinkList;
5. while(s->next != p)
6. s = s->next;
7. s->next = s->next->next;
8. delete(p);
9. }

这个算法主要耗时在于查找前一个结点，所以是O(n)的算法。

那么既然要求是O(1)，显然不能再去for一遍了，联想到数组的删除，这个问题就比较好解决了。

首先我们很容易就能得到待删除结点，即B结点的后一个结点C，然后将C的值赋值给B结点的值，相当于数组删除时候的覆盖，现在B结点和C结点一模一样了，接下来就相当简单了吧，我们不删B，直接利用B删掉C就行了，方法简单，时间O(1)。

但是仔细想想这个算法有个很明显的缺陷，如果待删除结点是最后一个结点呢？这个时候似乎没有什么好的解决办法，只能老老实实的O(n)了。现在我们来看看平均时间复杂度：

符合题目要求。

[cpp] view plaincopyprint?

1. void DeleteNode_O1(node *LinkList, node *p)
2. {
3. printf("delete:%d\n", p->val);
4. if(p->next != NULL) //如果p不是末尾结点, 则让后一个结点覆盖掉p, 然后删除后一个结点
5. {
6. p->val = p->next->val;
7. node *tmp = p->next;
8. p->next = p->next->next;
9. delete(tmp);
10. }
11. else // 如果p是末尾结点, 则找到p的前一个结点然后正常删除
12. {
13. node *s = LinkList;
14. while(s->next != p)
15. s = s->next;
16. s->next = s->next->next;
17. delete(p);
18. }
19. }

最后附上完整测试代码：

[cpp] view plaincopyprint?

1. #include<iostream>
2. using namespace std;
3. struct node
4. {
5. int val;
6. node* next;
7. };
8. void CreateLinkList(node *LinkList)
9. {
10. node *s = LinkList;
11. for(int i = 0; i < 10; i++)
12. {
13. node *t = new node;
14. t->val = i;
15. t->next = NULL;
16. s = s->next = t;
17. }
18. }
19. void ShowLinkList(node * LinkList)
20. {
21. node *s = LinkList->next;
22. while(s = s->next)
23. printf("%d ", s->val);
24. putchar(10);
25. }
26. void DeleteNode_On(node *LinkList, node *p)
27. {
28. printf("delete:%d\n", p->val);
29. node *s = LinkList;
30. while(s->next != p)
31. s = s->next;
32. s->next = s->next->next;
33. delete(p);
34. }
35. void DeleteNode_O1(node *LinkList, node *p)
36. {
37. printf("delete:%d\n", p->val);
38. if(p->next != NULL) //如果p不是末尾结点, 则让后一个结点覆盖掉p, 然后删除后一个结点
39. {
40. p->val = p->next->val;
41. node *tmp = p->next;
42. p->next = p->next->next;
43. delete(tmp);
44. }
45. else // 如果p是末尾结点, 则找到p的前一个结点然后正常删除
46. {
47. node *s = LinkList;
48. while(s->next != p)
49. s = s->next;
50. s->next = s->next->next;
51. delete(p);
52. }
53. }
54. int main()
55. {
56. node *LinkList = new node;
57. CreateLinkList(LinkList);
58. ShowLinkList(LinkList);
59. node *p = LinkList->next;
60. for(int i = 0; i < 3; i++)
61. p = p->next;
62. DeleteNode_On(LinkList, p);
63. ShowLinkList(LinkList);
64. p = LinkList->next;
65. for(int i = 0; i < 8; i++)
66. p = p->next;
67. DeleteNode_O1(LinkList, p);
68. ShowLinkList(LinkList);
69. p = LinkList->next;
70. for(int i = 0; i < 4; i++)
71. p = p->next;
72. DeleteNode_O1(LinkList, p);
73. ShowLinkList(LinkList);
74. getchar();
75. return 0;
76. }

如何在O(1)的时间里删除单链表的结点