数据结构 链表

内存的重复释放

编译器：Code::Blocks 16.01
操作系统：Windows 7旗舰版 sp1

最近写链表实验时，在写连接两个链表的函数的时候会出现奇怪的错误，究其原因在于内存的重复释放。

而内存的重复释放会比内存泄漏更加严重。 —— [为什么重复free()比内存泄漏危害更大]

代码块

代码块语法遵循标准markdown代码，例如：

class Node
{
    public:
        elementType m_iData;//节点数据
        Node *m_pNext;//next指针
};

class List
{
    public:
        Node *m_pHead;//链表的头指针
        int m_iLength;//链表的长度

        void CombinationList(List other);//实现连接链表功能的函数
};

void List::CombinationList(List other)
{
    if(other.EmptyList())
        return ;
    Node *p = m_pHead;
    while(p->m_pNext != NULL)
    {
        p = p->m_pNext;
    }
    p->m_pNext = other.m_pHead->m_pNext;
    m_iLength += other.m_iLength;
    return ;
}

最初写的函数是将第二个链表从第一个有效节点开始，直接接到第一个链表的尾部，
从而实现将两个链表连接，而第二个链表本身并不改变。
而这样写就会在将两个链表销毁的时候出现内存重复释放的问题。

之前出现错误时会出现，链表并未删除完全，再重新插入时会在保留数据时候继续插入的问题。
但在更改之后，重新运行错误代码，结果又会正确（至今未懂）。

实现结果为：

Group 1:
List A:
1 3 6 10 15 16 17 18 19 20
List B:
1 2 3 4 5 6 7 8 9 10 18 20 30
List Result:
1 3 6 10 15 16 17 18 19 20 1 2 3 4 5 6 7 8 9 10 18 20 30

Group 2:
List A:
1 3 6 10 15 16 17 18 19 20
List B:
2 4 5 7 8 9 12 22
List Result:
1 3 6 10 15 16 17 18 19 20 2 4 5 7 8 9 12 22

Group 3:
List A:
链表为空！
List B:
1 2 3 4 5 6 7 8 9 10
List Result:
1 2 3 4 5 6 7 8 9 10
更改之后代码如下：

void List::CombinationList(List other)
{
    if(other.EmptyList())
        return ;
    Node *p=m_pHead;
    Node *q=other.m_pHead->m_pNext;
    Node *r;
    while(q != NULL)
    {
        if(p->m_pNext == NULL)
        {
            r=new Node(q->m_iData);
            r->m_pNext = p->m_pNext;
            p->m_pNext = r;
            q = q->m_pNext;
        }
        else if(p->m_pNext->m_iData > q->m_iData)
        {
            r=new Node(q->m_iData);
            r->m_pNext = p->m_pNext;
            p->m_pNext = r;
            q = q->m_pNext;
        }
        else
        {
            p=p->m_pNext;
        }
    }
    m_iLength += other.m_iLength;
    return ;
}

实现结果为：

Group 1:
List A:
1 3 6 10 15 16 17 18 19 20
List B:
1 2 3 4 5 6 7 8 9 10 18 20 30
List Result:
1 1 2 3 3 4 5 6 6 7 8 9 10 10 15 16 17 18 18 19 20 20 30

Group 2:
List A:
1 3 6 10 15 16 17 18 19 20
List B:
2 4 5 7 8 9 12 22
List Result:
1 2 3 4 5 6 7 8 9 10 12 15 16 17 18 19 20 22

Group 3:
List A:
链表为空！
List B:
1 2 3 4 5 6 7 8 9 10
List Result:
1 2 3 4 5 6 7 8 9 10

更改之后：
实现将两个递增有序的链表再按照递增顺序合并为一个新的链表，并保存在第一个链表中。

总结

除了这种改法以外，可以在之前错误的函数末尾加上一个clear函数，
实现将第二个链表的头结点的next指针指向NULL，在销毁时就不会产生内存重复释放的问题了！
之前听郝斌老师的课上曾说过，内存重复释放会出现莫名其妙的问题，而且会很难发现。
因此，在编写程序时应该时刻注意内存的申请与释放。