C++中的动态树

Question

我想制作一棵树，它可以在每个节点中有一些子节点，但我不知道它们的数量。树必须在小内存中使用（没有额外数据）以恒定时间到每个节点进行编码。我坚信我将创建具有值和子属性（值是 int，子项是堆栈）和指向该树中每个节点的指针数组的类树。我的问题是制作这个数组。我怎样才能在没有额外数据的情况下（std::vector 有时分配的内存比它需要的更多）和每个单元格的恒定时间？

一切正常，但我还需要固定时间到每个节点。我知道会有多少个节点，但我不知道如何制作每个节点的数组。它应该像这样工作： array[n];
A_Node *array[0]= new A_Node(16);
A_Node *n = new A_Node(1);
array[0]->addChild(n);
array[1]=n;
要么： *(数组+1)=n;

Answer 1

这是一个可能的例子。这不是一个完整的示例解决方案，但我希望你明白这一点。关键是你可以有一个指向节点的双指针，它基本上是一个指向树节点的指针数组。

然后，您可以自己重新分配大小，并在需要时根据需要重新分配大小。但是 std::vector 已经为您做到了，因此没有真正的理由不使用它，除非您想自己控制一切或进行实验，或者正在用 C 编写一些东西。无论如何希望这会有所帮助。

#include <stdio.h>
#include <stdlib.h>

// The initial buffer length of a node's children
#define BUFFER_LENGTH   5
// How much to multiply with if an addition of a child goes over the buffer
#define MULTIPLIER 2

///Your node class
class A_Node
{
    public:
    A_Node(int value,unsigned int childrenN=0)
    {
        this->value = value;
        this->childrenN = childrenN;

        //allocate BUFFER_LENGTH children for the node at first or childrenN if the childrenN is not initially 0
        if(childrenN != 0)
        {
            this->children = (A_Node**) malloc(sizeof(A_Node*)*childrenN);
            this->bufferLength = childrenN;
        }
        else
        {
            this->children = (A_Node**) malloc(sizeof(A_Node*)*BUFFER_LENGTH);
                        this->bufferLength =BUFFER_LENGTH;
        }
    }

    //in the destructor of a node it would need some special care
    ~A_Node()
    {
        //for every child call the destructor of each child
        for(int i = 0; i < this->childrenN; i++)
        {
            delete this->children[i];
        }

        //and only then free the buffer of the pointers to the children
        free(this->children);
    }

    //adds a child
    void addChild(A_Node* child)
    {
        //reallocate if needed
        if(childrenN >= this->bufferLength)
        {
            realloc(this->children,sizeof(A_Node*)*MULTIPLIER);
        }

        this->children[childrenN] = child;
        this->childrenN++;
    }

    A_Node* getChild(unsigned int i)
    {
        if(i >= this->childrenN)
        {
            return 0;
        }

        return this->children[i];
    }

    void printValue()
    {
        printf("%d\n",this->value);
    }
private:
    int value;
    unsigned int childrenN;
    A_Node** children;
    unsigned int bufferLength;
};

///Your tree class
class A_Tree
{
    public:
        //constructor
        A_Tree(int rootValue)
        {
            root = new A_Node(rootValue);
        }
        //destructor
        ~A_Tree()
        {
            //recursively kills all the nodes due to the destructor of node
            delete root;
        }
        //your root node
        A_Node* root;
};


int main()
{
    A_Tree tree(16);

    tree.root->addChild(new A_Node(42));

    tree.root->printValue();

    (tree.root->getChild(0))->printValue();


    return 0;
}

Answer 2

只需自己跟踪内存，而不是使用向量：

class Node {
public:
    // In the constructor, initialize your array of children to NULL
    // and the size of your children array to zero
    Node() : mChildren(NULL), mSize(0) {}

    void AddChild(Node* newChild) {
        // allocate space for your new array
        Node** newArray = new Node*[mSize + 1];

        // copy over nodes from old array to new array
        for (int i = 0; i < mSize; i++) {
            newArray[i] = mChildren[i];
        }

        // add in our new child to the end of the array
        newArray[mSize++] = newChild;

        // if there was an old array (null check) free the memory
        if (mChildren) {
            delete [] mChildren;
        }

        // set our children array equal to our new array
        mChildren = newArray;
    }

    Node* AccessChild(size_t index) {
        // make sure it's a valid index and then return
        assert(index < mSize);
        return mChildren[index];
    }

private:
    Node** mChildren;
    int mSize;
};

这将没有额外的空间用于额外的节点，但它需要一个 int 的大小，以便跟踪您存储的节点数量。如果没有这个或有固定数量的孩子，我看不出有什么办法可以做到。

请注意，每次需要重新分配向量时，它们的大小都会翻倍，因为这样更有效。虽然上述解决方案在内存方面会更有效，但在性能方面会受到很大影响，因为它需要为每个添加子节点进行分配，这将需要 O(N) 分配来添加 N 个节点。

向量的性能将是 O(log(N)) 分配来添加 N 个节点，但同样，这个解决方案听起来像它具有您正在寻找的内存效率。