Question

根据传递给我的结构，我需要动态地将子节点添加到树的特定分支。例如，我有这样的结构：

  struct my_struct
  {
  int a;
  int b;
  char c;
  }

在我的函数中，在移动到所需的节点后，我应该能够将子节点添加到特定节点，如下所示：

                  root
                   |
      son------daughter----another_son
       |
   a---b--c

我的树节点结构如下：

struct tree{
   string name;
   int child_count;
   int value;
   vector< tree* > child;
};

由于我想稍后更新这些变量，我希望将结构中每个变量的节点分开。由于结构可以在我不知情的情况下更新，我希望逻辑与结构无关。

Answer 1

嗯，我可以建议一种方法，而不是太深入细节。我会设置类似于下面的代码。基本上有一个通用的结构允许某种简化的内省，通过重新定义子结构中的两个纯虚方法，算法将能够将结构“树 - 结构”到子节点中。最后，您将找到树“导航”的示例。嗯，这只是一个非常快速的例子，绝不是它可以被认为是详尽无遗的，你会注意到它没有为更复杂的结构实现任何类型的树递归。无论如何，我不知道选择结构而不是类来处理所有这些的原因。想一想！

#include <vector>
#include <string>
#include <iostream>

// Allowed data types
enum MyTypes {
    INT,
    DOUBLE,
    NODATA
};

// Base source struct
struct MyBaseStruct {
    std::vector <std::string> ids;
    virtual MyTypes getType(std::string id) = 0;
    virtual void *getPointer(std::string id) = 0;
};

// Example of used struct
struct MyStructA: MyBaseStruct {
    int a;
    double b;
    MyStructA();
    MyTypes getType(std::string id);
    void *getPointer(std::string id);
};

MyStructA::MyStructA()
{
    ids.push_back("a");
    ids.push_back("b");
}

MyTypes MyStructA::getType(std::string id)
{
    if (id == "a")
        return INT;
    else if (id == "b")
        return DOUBLE;
    return NODATA;
}

void *MyStructA::getPointer(std::string id)
{
    if (id == "a")
        return static_cast <void *> (&a);
    else if (id == "b")
        return static_cast <void *> (&b);
    return 0;
}

struct MyTreeNode {
    std::string id;
    MyTypes type;
    void *pointer;
    std::vector <MyTreeNode *> children;
    void addChildren(MyBaseStruct &data);
};

void MyTreeNode::addChildren(MyBaseStruct &data)
{
    std::vector <std::string>::const_iterator i(data.ids.cbegin());
    while (i != data.ids.cend()) {
        MyTreeNode *newNode= new MyTreeNode;
        newNode->id= (*i);
        newNode->type= data.getType(*i);
        newNode->pointer= data.getPointer(*i);
        children.push_back(newNode);
        i++;
    }
}

int main(int /*argc*/, char * /*argv[]*/)
{
    MyStructA a;
    a.a= 1;
    a.b= 12.34;

    MyTreeNode treeRoot;
    treeRoot.id= "root of my tree";
    treeRoot.type= NODATA;
    treeRoot.pointer= 0;
    treeRoot.addChildren(a);

    // Example of tree navigation
    std::vector <MyTreeNode *>::const_iterator i(treeRoot.children.cbegin());
    while (i != treeRoot.children.cend()) {
        std::cout << (*i)->id << ": ";
        if ((*i)->pointer) {
            if ((*i)->type == INT) {
                std::cout << *(static_cast <int *> ((*i)->pointer)) << "\n";
            }
            if ((*i)->type == DOUBLE) {
                std::cout << *(static_cast <double *> ((*i)->pointer)) << "\n";
            }
        }
        i++;
    }
}

如果您有时间，您还可以考虑编写一种变体类来处理不同类型的数据类型，并且无需在多个位置投射您的值。

Answer 2

struct tree{
   string name;
   my_struct structure;
   int sonc;
   vector< tree* > child;
};

我建议您使用Node作为树节点的结构名称（那些组合树的节点）并为不同深度的树中的节点使用“parent”和“child”等术语。

顺便说一句，如果你希望遍历树向上，我建议添加另一个指向节点父节点的指针。

然后编写一个函数，你有一个节点（树）作为你添加孩子的参数......

像这样：

addToTree(tree node, other parameters, like struct...)
{
    tree newNode = new tree();
    //do what you want with the new node...

    node.children.add(newNode);
    node.sonc++;
    newNode.Parent = node;
}

Answer 3

使用数据类型

struct data {
   string name;
   my_struct structure;
   int sonc;
};

并定义您的树通常。

现在我建议使用Boost容器，这样你就可以创建一个不完整类型的vector / list / deqeue：

template <typename Data>
struct node
{
    Data _data;
    boost::deque<node> _children;
};

或者，如果您喜欢继承，这也可以是有效的：

template <typename Data>
struct node : public Data
{
    boost::deque<node> _children;
};

这样可以免除手动分配管理带来的麻烦。

另外，您可以使用std::unique_ptr<node>来避免手动执行内存管理（提示：很难才能做到正确。想想异常安全，自我分配，循环）

甚至，使用boost :: variant：

typedef boost::make_recursive_variant<data, std::vector<boost::recursive_variant_> >::type tree;

最让你满意的将取决于申请。

从未知的struct C ++构造树（非二进制）结构

3 个答案:

这样可以免除手动分配管理带来的麻烦。