Question

我有一个具有这种结构的节点：

struct node
{
    unsigned long key;
    unsigned long value;
    struct node* lChild;    
    struct node* rChild;   
};

我有一个虚拟节点，它有默认值：

struct node* newSpecialNode()
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = 0;
    node->value = 0;
    node->lChild = NULL;
    node->rChild = NULL;
    return(node);
}

我的数据结构中的所有节点都将调用此方法来创建节点。

struct node* newInternalNode(unsigned long key, unsigned long value)
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = key;
    node->value = value;
    node->lChild = newSpecialNode();
    node->rChild = newSpecialNode();
    return(node);
}

我为左右孩子调用函数newSpecialNode()。所以有两个malloc次调用。但每当我创建一个节点时，我总是创建两个虚节点。所以我想做一个malloc，为lChild和rChild分配内存。可能会分配一个双字并引用其部分。但我不知道该怎么做。

我试过这种方法。但我又需要做两个mallocs。

struct node** ptrToTwoNodes = (struct node**) malloc(2*sizeof(struct node*));
ptrToTwoNodes[0] = (struct node*) malloc(sizeof(struct node));
ptrToTwoNodes[1] = (struct node*) malloc(sizeof(struct node));

Answer 1

虽然从技术上讲，你可以用一个malloc()来分配所有三个节点，但你真的不应该这样做，因为它打破了递归的对称性＃34;树形结构。

当调用malloc()三次时，会得到一个树，其中每个节点彼此独立。这意味着您可以稍后更改树（添加和删除节点），而不必担心如何分配子节点。

问题的根源在于，您无法free()部分内存片段返回malloc()。对于free()返回的每个指针，您总是必须为malloc()完全调用一次 - 不多也不少。

如果malloc对你来说过于昂贵，那么另一种方法是创建一组辅助函数来保存节点结构池（因此它们一次分配N然后一个接一个地返回，直到池用完为止）。请参阅object pool pattern。

Answer 2

如果要为两个节点分配单个内存块，请尝试

struct node* ptrToTwoNodes = (struct node*) malloc(2*sizeof(struct node));

然后&ptrToTwoNodes[0]和&ptrToTwoNodes[1]将指向您的两个节点。顺便说一句，我想你应该删除C ++标签。

Answer 3

您可以为2个节点分配内存，并将指针指定给变量：

struct node* ptrToTwoNodes = (struct node*) malloc(2*sizeof(struct node));
ptrToTwoNodes[0].value = ...;
ptrToTwoNodes[1].value = ...;

Answer 4

我不确定你的最终结果是什么，但你可以这样做：

struct node
{
    unsigned long key;
    unsigned long value;
    struct node* Child;    //allocate two 2 node sized blocks for it & access left-Child[0], right-Child[1]
};

并初始化为：

struct node* newSpecialNode()
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = 0;
    node->value = 0;
    node->Child = NULL;
    return(node);
}

然后分配如：

struct node* newInternalNode(unsigned long key, unsigned long value)
{
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = key;
    node->value = value;
    node->Child = malloc(sizeof(sruct node)*2); //Child[0] & Child[1] 
    return(node);
}

Answer 5

修改代码如下：

struct node * newSpecialNode(void)
{
  struct node * node = malloc(2 * sizeof(*node));
  node->key = 0;
  node->value = 0;
  node->lChild = NULL;
  node->rChild = NULL;
  ++node;

  node->key = 0;
  node->value = 0;
  node->lChild = NULL;
  node->rChild = NULL;
  --node;

  return node;
}

struct node * newInternalNode(unsigned long key, unsigned long value)
{
  struct node * node = malloc(sizeof(*node));
  node->key = key;
  node->value = value;
  node->lChild = newSpecialNode();
  node->rChild = node->lChild + 1; 

  return node;
}

注意如何free()事情。

还要向所有malloc()添加错误检查。

同样^ 2：In C there is no need to cast the result of malloc(), nor is it recommended.

用于创建2个结构的单个malloc

5 个答案: