Question

列出属性：一个指针指向下一个节点，另一个指针指向列表中的任意节点。

结构

struct node
{
    int val;
    node* link[2];
    node(int x);
    ~node();
};
node :: node(int x)
{
    val = x;
    link[0] = NULL;
    link[1] = NULL;
}
node :: ~node()
    {
        delete(link[0]);
        delete(link[1]);
    }

类

class List
{
    node *head, *cloneHead;
    node *stack[100];
    int childIndex[2][100];
    int stptr;
public:
    List();
    ~List();
    void createList(int[] , int[][2], int );
    int createListStruct(node*);
    void createCloneList();
    void clone();
    void printClone();
};

创建列表

void List::createList(int a[], int child[][2], int size)
{
    node* linkedList[size];
    for(int i=0;i<size;i++)
    {
        linkedList[i] = new node(a[i]);
    }
    head = linkedList[0];
    for(int i=0;i<size;i++)
    {
        for(int j=0;j<2;j++)
        {
            if(child[i][j]!=-1)
            {
                linkedList[i]->link[j] = linkedList[child[i][j]];
            }
        }
    }
}

主要

int main()
{
    int a[]={10,1,3,7,2,8,20};
    int child[][2] = {{1,4},{1,2},{3,-1},{6,5},{6,5},{-1,0},{5,5}};
    int size = sizeof(a)/sizeof(a[0]);
    List L;
    L.createList(a,child,size);
    L.clone();
    L.printClone();
    return 0;
}

在正常情况下，析构函数完美地工作，但是对于具有上述List属性的列表，它的失败

例如：

节点：1

Link1：节点2

Link2：节点3

节点：2

Link1：节点3

Link2：节点1

在上述情况下，当析构函数到达Node2的Link2时，指向节点1，节点1已被删除，因此代码抛出了分段错误。

我提出：在列表中有一系列唯一节点并逐个删除

还有其他办法吗？

Answer 1

您可以使用shared_ptr，并在最后一个指针被销毁或重新分配时释放内存。你唯一需要记住的就是避免循环，这就是为什么任意节点ponter改为使用weak_ptr。

struct node; // forward declaration

struct node
{
    int val;
    shared_ptr<node> next;
    weak_ptr<node> other;
};

Answer 2

您的列表创意的两种替代方案（似乎没问题）

对于每个节点，请保留父母列表。删除节点后，将其指向该节点的所有父节点设置为nullptr。您可以根据需要随时删除nullptr。
如果您的图表是树（即没有周期），您可以使用共享指针或unique_pointers进行引用计数

删除自定义双向链表

2 个答案: