剑指offer---以O(1)时间删除链表节点

问题：删除链表节点

要求：以O(1)时间

对于删除指定索引的链表元素大家都很熟悉，思路一般是从头遍历链表直到指定索引位置删除元素，然后维护一下指针即可，时间复杂度O(n)。代码如下：

 // 删除position位置的数据，并返回
 int List::erasePosition(int position){
     if(position< || position>(List::size()-)){
         cout<<"position error, please check."<<endl;
         return -;
     }
     int res = List::getValue(position);
     Node *p = head;
     int index = ;
     cout<<"erase data at position "<<position<<endl;
     if(position == ){
         head = p->next;
         return res;
     }
     else{
         while(index != position-){
             p = p->next;
             index++;
         }
         Node *temp = p->next;
         p->next = temp->next;
         return res;
     }
 }

上述代码的完整版在这里。

但是当删除指定地址的链表元素时，事情变得不太一样了，在这种情况下我们可以实现O(1)时间删除指定地址的数据。当然，以上是基于一个假设：要删除的节点一定在链表里面。

如上图所示，我们打算删除节点e，可以将节点e的后一个节点b的内容复制到节点e，即覆盖原有内容，然后删除后一个节点b。（这里我感觉待删除地址还是有节点的，只是内容变了，与直接删除节点e有相似的效果）

注意点：空指针与尾节点的情况（详见代码）

解题代码：

 void List::erase(Node *pDelete){
     if (pDelete == nullptr)
         return ;
     // 删除的的节点不是尾节点
     if(pDelete->next != nullptr){
         Node *pNext = pDelete->next;
         pDelete->data = pDelete->next->data;
         pDelete->next = pNext->next;
         delete pNext;
         pNext = nullptr;
     }
     // 链表只有一个节点，删除第一个节点
     else if(head == pDelete){
         delete pDelete;
         pDelete = nullptr;
         head = nullptr;
     }
     // 链表中有多个节点，要删除尾节点
     else{
         Node *p = head;
         while(p->next!= pDelete){
             p = p->next;
         }
         p->next = nullptr;
         delete pDelete;
         pDelete = nullptr;
     }
 }

完整版代码：

 #include<iostream>
 using namespace std;

 class Node {
 public:
     int data;
     Node *next;
     Node(int da):
         data(da), next(NULL){}
 };

 class List{
 public:
     Node *head;
     List(): head(NULL){}
     ~List(){
         delete head;
         cout<<"The list is deleted."<<endl;
     };
     int size();
     int getValue(int position);
     void printList(); // 打印链表
     void insert(int position, int value); // 指定位置插入
     void insertHead(int value); // 插入到最前
     void insertTail(int value); // 插入到最后
     int erasePosition(int position); // 删除指定位置的节点
     void erase(Node *pDelete);

 };

 // 返回position位置的数据
 int List::getValue(int position){
     if(position< || position>(List::size()-)){
         cout<<"position error, please check."<<endl;
         return -;
     }
     Node *p = head;
     int index = ;
     while(index != position){
         p = p->next;
         index++;
     }
     //cout<<"position "<<position<<" is "<<p->data<<endl;
     return p->data;
 }

 // 返回链表大小
 int List::size(){
     Node *p = head;
     int index = ;
     while(p != NULL){
         index++;
         p = p->next;
     }
     return index;
 }

 // 打印链表
 void List::printList(){
     Node *p = head;
     while(p != NULL){
         cout<<p->data<<" ";
         p = p->next;
     }
     cout<<endl;
     cout<<endl;
 }

 // 在position位置插入value
 void List::insert(int position, int value){
     if(position< || position>List::size()){
         cout<<"position error, please check."<<endl;
         return ;
     }
     Node *s = new Node(value); // new node
     Node *p = head;
     if(head == NULL){ // isEmpty = true
         head = s;
     }
     else{ // isEmpty = false
         if(position == ){
             s->next = p;
             head = s;
         }
         else{
             int index = ;
             while(index != position-){
                 p = p->next;
                 index++;
             }
             s->next = p->next;
             p->next = s;
         }
     }
     if (position == )
         cout<<"insert "<<value<<" at the first."<<endl;
     else if (position == List::size())
         cout<<"insert "<<value<<" at the tail."<<endl;
     else
         cout<<"insert "<<value<<" at position "<<position<<endl;
 }

 // 头部插入
 void List::insertHead(int value){
     List::insert(, value);
 }

 // 尾部插入
 void List::insertTail(int value){
     List::insert(List::size(), value);
 }

 // 删除position位置的数据，并返回
 int List::erasePosition(int position){
     if(position< || position>(List::size()-)){
         cout<<"position error, please check."<<endl;
         return -;
     }
     int res = List::getValue(position);
     Node *p = head;
     int index = ;
     cout<<"erase data at position "<<position<<endl;
     if(position == ){
         head = p->next;
         return res;
     }
     else{
         while(index != position-){
             p = p->next;
             index++;
         }
         Node *temp = p->next;
         p->next = temp->next;
         return res;
     }
 }

 void List::erase(Node *pDelete){
     cout<<"erase data at address "<<pDelete<<endl;
     if (pDelete == nullptr)
         return ;
     // 删除的的节点不是尾节点
     if(pDelete->next != nullptr){
         Node *pNext = pDelete->next;
         pDelete->data = pDelete->next->data;
         pDelete->next = pNext->next;
         delete pNext;
         pNext = nullptr;
     }
     // 链表只有一个节点，删除第一个节点
     else if(head == pDelete){
         delete pDelete;
         pDelete = nullptr;
         head = nullptr;
     }
     // 链表中有多个节点，要删除尾节点
     else{
         Node *p = head;
         while(p->next!= pDelete){
             p = p->next;
         }
         p->next = nullptr;
         delete pDelete;
         pDelete = nullptr;
     }
 }

 int main() {
     List l1;
     l1.insertTail();
     l1.insertHead();
     l1.insert(, );
     l1.insert(, );
     l1.insert(, );
     l1.insert(, );
     l1.insert(, );
     cout<<endl<<"The list is:"<<endl;
     l1.printList();
     l1.erasePosition();l1.printList();
     l1.erase(l1.head);l1.printList();
     return ;
 }

运行结果：

 insert  at the first.
 insert  at the first.
 insert  at position
 insert  at the first.
 insert  at position
 insert  at the first.
 insert  at position 

 The list is:

 erase data at position 

 erase data at address 0x3b1a58

 The list is deleted.
 [Finished in .3s]

由于主函数传的是 l1.erase(l1.head); 所以应该是删除链表的第一个节点，可见结果正确。