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)]
          |                                |                          |
_______________                    _________________        __________________________
|    |    |   |                   |        |       |        |    |    |     |    |   |
[*   *    *   *]                  [*       *       *]      [*    *    *     *    *   *]

**代表Node。我不想declare all children of a node at the same time，即我希望在其one by one时添加子节点required。例如o以root身份添加，然后将节点1添加为root的子节点（如果需要），然后添加节点2，依此类推。[* * * *]表示节点x的子节点。

修改：
人们假定NoOfChild为maximum no of a child，因为给定的节点不是真的，这里NoOfChild表示一个节点在给定的实例中有多少个子节点，它可能根据需要或不时变化。
说明：
最初节点0已初始化，因此它具有零（0）子节点然后节点1被添加为节点0的子节点，因此o-＆gt; NoOfChild = 1和1 - ＆gt; NoOfChild = 0;
然后节点[*]被添加为节点1的子节点，因此0-＆gt; NoOfChild = 1和1 - ＆gt; NoOfChild = 1;
然后将2添加为节点0的子节点，因此0-＆gt; NoOfChild = 2和1 - ＆gt; NoOfChild = 1;
等等。

编辑：
最后使用vector<s*> child。

Answer 1

对于常规树数据结构，您可以使用： -

 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;

Answer 2

第一个答案是：你不是。在所示的评论中使用类似于每个人的容器类。

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

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 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

因为您标记了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 5

我解决了使用

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

这有助于提高，因为所有指针/引用都由STL管理。

如何在C ++中使用双重（**）指针来获得通用树数据结构？

5 个答案: