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

问题：删除链表节点

要求：以O(1)时间

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

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

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

// 删除position位置的数据，并返回
int List::erasePosition(int position){
    if(position<0 || position>(List::size()-1)){
        cout<<"position error, please check."<<endl;
        return -1;
    }
    int res = List::getValue(position);
    Node *p = head;
    int index = 0;
    cout<<"erase data at position "<<position<<endl;
    if(position == 0){
        head = p->next;
        return res;
    }
    else{
        while(index != position-1){
            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(6);
    l1.insertHead(7);
    l1.insert(1, 5);
    l1.insert(0, 16);
    l1.insert(2, 56);
    l1.insert(0, 169);
    l1.insert(6, 16);
    cout<<endl<<"The list is:"<<endl;
    l1.printList();
    l1.erasePosition(0);l1.printList();
    l1.erase(l1.head);l1.printList();
    return 0;
}

运行结果：

insert 6 at the first.
insert 7 at the first.
insert 5 at position 1
insert 16 at the first.
insert 56 at position 2
insert 169 at the first.
insert 16 at position 6

The list is:
169 16 7 56 5 6 16 

erase data at position 0
16 7 56 5 6 16 

erase data at address 0x3b1a58
7 56 5 6 16 

The list is deleted.
[Finished in 1.3s]

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