数据结构（王卓）（4）附：链表的销毁与清空

news2024/12/24 2:42:05

销毁

Status 销毁单链表(LinkList L)
{
    LinkList p;
    while (L)
    {
        p =L;
        L->next;
        delete p;
    }
    return OK;
}

运行逻辑：
（1）:设定一个指针，让指针指向链表的头指针L

（2）：让头指针等于头指针里面指向下一结点的结点内部指针next

（保存了头指针.next（L.next），即下一个结点的地址）

此时L的值为下一个结点的地址

（3）：删除这个我们设定的指针

这个我们设定的指针此时就是链表中的第一个结点的地址（头指针）

这一操作在我们的记录里删除了头结点的地址

与此同时里面存储的变量自然也没有内存空间存储了（该内容的内存空间区域都没了你还存啥）自然也就一同（一起）被释放，于是这个整一节点都被清除

然后再进入下一轮（头指针记为当前之后的第一个节点的地址，然后再释放这一结点，逐个清除）

......

最终：

L指向下一指针a（n）；

删除结点a（n-1）；

指针p指向a（n）；

p指向a（n）.next=^(空)；

删除

结点a（n）；

另外，如果我们在输入的时候，输入一个链表Lnode类型进去：

Status 销毁单链表(LinkList& L)
{
    //判断链表是否为空
    if (链表是否为空(L))
    {
        cerr << "empty List!" << endl;
        return false;
    }
    while (L)//链表还未到达尾端
    {
         Lnode* temp;
        temp = *&L;
        L = L->next;
        delete temp;
    }
    return true;
}

或者：

Status 销毁单链表(LinkList& L)
{
    //判断链表是否为空
    if (链表是否为空(L))
    {
        cerr << "empty List!" << endl;
        return false;
    }
    while (L)//链表还未到达尾端
    {
        auto temp = L->next;//将头指针指向下一个结点
        delete L;
        L = temp;
    }
    return true;
}

清空（只销毁内容）

project 1：（其实只是对销毁链表的生搬硬套的照抄，并且里面还缺少了while语句的循环）

Status 清空链表(Lnode *&L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    auto temp = *&L;
    L = L->next;
    delete (*temp);
}

project 2：

Status 清空链表(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    while (L)
    {
        auto temp = L;
        delete L->data;
        L = L->next;
    }

}

结果他说清空链表是指清空中间的所有结点，但是保留头结点（也包括头指针）（为空）

而不是清空链表中每一结点存储的数据内容，remake：

project 3：

Status 清空链表(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    while (L)
    {
        auto temp = L->next;
        delete L;
        L = temp;
    }
}

整个程序运行的流程逻辑链路还是没有完成闭环

project 4：

Status 清空链表(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    while (L)
    {
        auto temp = L->next;
        L = temp;
        L = L->next;
        delete temp;
    }
}

注意：在这里，我们不能再用L来指向第二个节点的地址，因为如果这样（使）用：

第一轮：

（1）：temp指向第一个结点

（2）：L指向第一个结点

（3）：L指向第二个节点

（4）：删除第一个节点

第二轮：
（1）：temp指向第三个节点

（2）：L指向第三个节点

（3）：L指向第四个结点

（4）：删除第3个节点

......

这样一来，第二个节点就没删掉；

而且，因为一次跳两个，倒数第二个就未必给你跳（没机会了，后面没有了））

project 5:

Status 清空链表(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    while (L)
    {
        auto temp1 = L->next;
        auto temp2 = temp1->next;
        delete temp1;
        temp1=temp2;
    }
}

但是我们编到这里我们肯定也知道，如果这样的话这个程序他就是一直在用L赋值

这样到后面肯定是不行的，所以继续改进：

project 6:

Status 清空链表(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    auto temp1 = L->next;
    while (temp1)
    {
        auto temp2 = temp1->next;
        delete temp1;
        temp1=temp2;
    }
}

最后别忘了，我们要的是一个空的头结点，并且在完成操作后，我们还需要返回一个操作成功执行的信号：

project 7: 最终成品版本

Status 清空链表(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    auto temp1 = L->next;
    while (temp1)
    {
        auto temp2 = temp1->next;
        delete temp1;
        temp1=temp2;
    }
    L->next = NULL;
    return true;
}

最后：

temp1指向a（n-1），temp2指向a（n）；

删除 a（n-1）；

temp1指向a（n）;

while(1)（通过）

temp2指向a（n）.next=^(空)；

删除 a（n）；

temp1也指向a（n）.next=^(空)；

清空L->next；

结束；

问题：

为什么（我们何必）还要再去设立一个新的变量temp2，我们直接去使用头结点L记录后面的地址不就完了吗？何必这么多此一举？

Status 清空链表(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    auto temp1 = L->next;
    while (temp1)
    {
        L = temp1->next;
        delete temp1;
        temp1=L;
    }
    L->next = NULL;
    return true;
}