删除链表结点要求O(1)时间复杂度

一，题目

       给定链表的头指针和一个结点指针，在O(1)时间删除该结点。链表结点的定义如下：
struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

函数的声明如下：
          void DeleteNode(ListNode* pListHead, ListNode* pToBeDeleted);

二，分析

        这是一道广为流传的Google面试题，能有效考察我们的编程基本功，还能考察我们的反应速度，更重要的是，还能考察我们对时间复杂度的理解。
在链表中删除一个结点，最常规的做法是从链表的头结点开始，顺序查找要删除的结点，找到之后再删除。由于需要顺序查找，时间复杂度自然就是O(n)了。

         我们之所以需要从头结点开始查找要删除的结点，是因为我们需要得到要删除的结点的前面一个结点。

      “狸猫换太子法”：可以从给定要删除的结点得到它的下一个结点。这个时候我们实际删除的是它的下一个结点，在删除之前，我们需要需要把给定的结点的下一个结点的数据拷贝到给定的结点中，然后删除该节点的下一个节点。此时，时间复杂度为O(1)。

         上面的思路还有一个问题：如果删除的结点位于链表的尾部，没有下一个结点，怎么办？我们仍然从链表的头结点开始，顺便遍历得到给定结点的前序结点，并完成删除操作。这个时候时间复杂度是O(n)。

         那题目要求我们需要在O(1)时间完成删除操作，我们的算法是不是不符合要求？实际上，假设链表总共有n个结点，我们的算法在n-1总情况下时间复杂度是O(1)，只有当给定的结点处于链表末尾的时候，时间复杂度为O(n)。那么平均时间复杂度[(n-1)*O(1)+O(n)]/n，仍然为O(1)。

 

三，源码

[html] view plaincopyprint?

1. #include <iostream>  
2. using namespace std;  
3.    
4. struct Node  
5. {  
6.       int    data;  
7.       Node*  next;  
8.   
9. };  
10.   
11. Node *creat()  
12. {  
13.     Node *head=new Node();  
14.     head->data=0;  
15.     head->next=NULL;  
16.       
17.     for(int i=10;i>0;--i)  
18.     {  
19.         Node *temp=new Node();  
20.         temp->data=i;  
21.         temp->next=NULL;  
22.           
23.         temp->next=head->next;  
24.         head->next=temp;  
25.            
26.     }   
27.       
28.     return head;  
29.        
30. }   
31. Node *findLastNode(Node *head,int data)  
32. {  
33.       
34.     while(head!=NULL&&head->data!=data)  
35.     {  
36.         head=head->next;   
37.           
38.     }   
39.     return head;   
40. }   
41. void deleteNode(Node *head,Node *del)  
42. {  
43.     if(del->next!=NULL)  
44.     {  
45.         del->data=del->next->data;  
46.         del->next=del->next->next;   
47.     }   
48.     else  
49.     {  
50.        /*这是我们删除最后节点的办法*/   
51.         Node *pre=findLastNode(head,9);   
52.         pre->next=pre->next->next;   
53.           
54.     }   
55.       
56. }   
57. void print(Node *head)  
58. {  
59.     while(head!=NULL)  
60.     {  
61.         cout<<head->data<<" ";  
62.         head=head->next;   
63.     }   
64. }   
65. int main()  
66. {  
67.       
68.     Node *head=creat();   
69.     print(head);   
70.       
71.   
72.       
73.     /*O(1)策略删除一个给定元素*/   
74.     Node *del=findLastNode(head,8);   
75.     deleteNode(head,del);   
76.       
77.     /*O(n)策略删除结尾元素*/   
78.     Node *del2=findLastNode(head,10);   
79.     deleteNode(head,del2);   
80.       
81.       
82.       
83.     /*这种方法不可取*/   
84.     //delete last;  
85.     //last=NULL;   
86.     //cout<<"last :"<<last->data<<endl;   
87.       
88.     cout<<endl;   
89.     print(head);   
90. }   

#include <iostream>using namespace std; struct Node{      int    data;      Node*  next;};Node *creat(){Node *head=new Node();head->data=0;head->next=NULL;for(int i=10;i>0;--i){Node *temp=new Node();temp->data=i;temp->next=NULL;temp->next=head->next;head->next=temp; } return head; } Node *findLastNode(Node *head,int data){while(head!=NULL&&head->data!=data){head=head->next; } return head; } void deleteNode(Node *head,Node *del){if(del->next!=NULL){del->data=del->next->data;del->next=del->next->next; } else{   /*这是我们删除最后节点的办法*/ Node *pre=findLastNode(head,9); pre->next=pre->next->next; } } void print(Node *head){while(head!=NULL){cout<<head->data<<" ";head=head->next; } } int main(){Node *head=creat(); print(head); /*O(1)策略删除一个给定元素*/ Node *del=findLastNode(head,8); deleteNode(head,del); /*O(n)策略删除结尾元素*/ Node *del2=findLastNode(head,10); deleteNode(head,del2); /*这种方法不可取*/ //delete last;//last=NULL; //cout<<"last :"<<last->data<<endl; cout<<endl; print(head); } 

         值得注意的是，为了让代码看起来简洁一些，上面的代码基于两个假设：

       （1）给定的结点的确在链表中；

                不考虑第一个假设对代码的鲁棒性是有影响的。

       （2）给定的要删除的结点不是链表的头结点。

                至于第二个假设，当整个列表只有一个结点时，代码会有问题。但这个假设不算很过分，因为在有些链表的实现中，会创建一个虚拟的链表头，并不是一个实际的链表结点。这样要删除的结点就不可能是链表的头结点了。