如何在 C++ 中将双重（**）指针用于通用树数据结构？

Question

我有一个结构 s：

struct s{
   int x;
  /********************************************************************
   *  NoOfchild doesn't represent maximum no of children for node s . 
   *  This represent no of children node s have at any given instance . 
   *********************************************************************/      
   int NoOfChild; 
   s  **child;
}

我想用**动态声明指针数组。节点 s 被一一添加到数组中。有什么方法可以实现。这棵树将用于FpGrowth Algorithm。

                                         *(0) 
                                           |
          _____________________________________________________________
          |                                |                          | 
       [* (1)                             *(2)                      *(3)]
          |                                |                          |
_______________                    _________________        __________________________
|    |    |   |                   |        |       |        |    |    |     |    |   |
[*   *    *   *]                  [*       *       *]      [*    *    *     *    *   *]

** 代表节点 s 。我不想 declare all children of a node at the same time 即我想添加子节点 one by one ，只要它是 required 。例如o 被添加为根节点，然后节点 1 被添加为根节点的子节点（如果需要），然后节点 2 被添加，依此类推。[* * * * ] 表示节点 x 的子节点。

编辑：
对于给定的节点，人们将 NoOfChild 假设为 maximum no of a child，这是不正确的，这里 NoOfChild 表示一个节点在给定实例中有多少个子节点，它可能会根据要求或时间而有所不同。
说明：强>
最初节点 0 已初始化，因此它有零 (0) 个子节点。
然后将节点 1 添加为节点 0 的子节点，因此 o->NoOfChild = 1 和 1 ->NoOfChild = 0 ;
然后将节点 [*] 添加为节点 1 的子节点，因此 0->NoOfChild = 1 和 1 ->NoOfChild = 1 ;
然后将 2 添加为节点 0 的子节点，因此 0->NoOfChild = 2 和 1 ->NoOfChild = 1 ;
等等。

编辑：
终于用vector<s*> child了。

Answer 1

我用

解决了

struct s{
   int x;
   vector<s*> child ;
}

这更有帮助，因为所有指针/引用都由 STL 管理。

Answer 2

既然你标记了 c++：

#include <vector>
#include <memory>
#include <algorithm>
#include <iostream>

template <class ValueType>
class VariadicTree
{
public:
    VariadicTree(const ValueType& value) : m_value(value), m_size(0)
    {
    }

    VariadicTree<ValueType>& addNode(const ValueType& value)
    {
        m_children.emplace_back(new VariadicTree<ValueType>(value));
        ++m_size;
        return *m_children.back();
    }

    bool leaf()
    {
        return std::all_of(m_children.begin(), m_children.end(),
                           [&](const std::unique_ptr<VariadicTree<ValueType>>& ptr)
                              {return ptr == nullptr;});
    }

    size_t size()
    {
        return m_size;
    }

    const ValueType& value()
    {
        return m_value;
    }

private:
    size_t m_size;
    const ValueType& m_value;
    std::vector<std::unique_ptr<VariadicTree<ValueType>>> m_children;
};

int main()
{
    VariadicTree<int> root(5);
    auto& c1 = root.addNode(4);
    auto& c2 = root.addNode(6);
    auto& c3 = root.addNode(2);

    auto& c11 = c1.addNode(2);

    std::cout << root.leaf() << "\n";
    std::cout << c11.leaf() << "\n";
    std::cout << root.size() << "\n";
    std::cout << c1.size() << "\n";
    std::cout << c11.size() << "\n";

    return 0;
}

所有权可能可以更优雅地处理，但这应该用于演示目的。

Answer 3

纯 c 版本：

struct node
{
    int key;
    int noOfChild;
    struct node** childrenArray;
};

struct node* newNode(int key, int noOfChild)
{
    int i;
    struct node* node = (struct node*) malloc(sizeof(struct node));
    node->key = key;
    node->noOfChild = noOfChild;
    node->childrenArray = (struct node**) malloc(noOfChild * sizeof(struct node*));
    for(i=0;i<noOfChild;i++)
    {
        node->childrenArray[i] = NULL;
    }
    return(node);
}

Answer 4

第一个答案是：你不知道。像所指示的 cmets 中的每个人一样使用容器类。

第二个答案是：动态分配：

void addNewChild(s *into, s* new_child)
{
   s **tmp_s = new s*[into->NoOfChild+1];    ///< will throw if allocation fails

   for(int i=0; i<into->NoOfChild; i++) tmps[i] = into->child[i];  ///< use a memcpy instead
   tmps[into->NoOfChild++] = new_child;

   s **del_s = into->child;
   into->child = tmp_s;
   delete[] del_s;
}

最后：不要这样做。使用std::vector<s> 或std::vector<s*>，具体取决于孩子可以拥有多少父母。

Answer 5

对于一般的树数据结构，您可以使用：-

 struct tree{
 int element;
 struct tree *firstchild;
 struct tree *nextsibling;
 };

元素包含要插入到节点的数据。

FirstChild 包含节点的第一个子节点。

nextsibling 包含同一父节点的另一个子节点。 示例：-

   A

 B  C  D

EF  G     H

那么 A->firstchild = B; B->nextsibling=C; C->nextsibling=D; B->firstchild=E; E->nextsibling=F; C->firstchild=g; D->firstchild=H;

其他未指定的值可以作为NULL；