多节点树结构

在某次项目中，需要遍历装配体，装配体中可能含有嵌套，需要用到一中数据结构，类似于二叉树，但节点数量可能大于2，

如下图：

最终需要处理出来的结果如下：

定义树结构如下来存储每个节点的信息，主要结构如下：

class TreeNode
{
    string name;
    vector<TreeNode*> children;//子节点
    TreeNode* parent;//父节点
}    

使用递归来解析，用容器map来存储最后的结果。

完整代码如下：

#include <vector>
#include <string>
#include <map>
using namespace std;
typedef map<string,unsigned> DataMap;
enum NodeType //节点类型
{
    UnknownNode,//未知
    TopAsmNode,//装配体
    SubAsmNode,//子装配体
    FileNode,//文件夹
    PartNode //零件
};

class FileData
{
private:
    string name;
    DataMap dataMap;
public:
    FileData(){}
    FileData(string s)
    {
        name = s;
    }
    string GetName()
    {
        return name;
    }
    DataMap GetDataMap()
    {
        return dataMap;
    }
    void AddPart(string s)
    {
        DataMap::iterator i = dataMap.find(s);
        if(i!=dataMap.end())
        {
            if(i->first==s)
                ++( i->second );
        }
        else
            dataMap.insert(pair<string,unsigned>(s,1));
    }
};

class NodeDataVec
{
private:
    vector<FileData> FileDataVec;
public:
    vector<FileData> GetFileData()
    {
        return FileDataVec;
    }
    void AddFileNode(string s)
    {
        FileData node(s);
        FileDataVec.push_back(node);
    }
    FileData *FindFileNode(string s)
    {
        for(unsigned i = 0;i<FileDataVec.size();++i)
        {
            if(FileDataVec[i].GetName() == s)
                return &FileDataVec[i];
        }
        return NULL;
    }

    NodeDataVec(){};
    ~NodeDataVec(){};
};

class TreeNode
{
private:
    NodeType nodeType;
    vector<TreeNode*> children;//子节点
    TreeNode* parent;//父节点
    string name;
public:
    void AnalyzeData(NodeDataVec &data)
    {
        for(unsigned i=0;i<children.size();++i)
        {
            switch (children[i]->GetNodeType())
            {
            case TopAsmNode:
                children[i]->AnalyzeData(data);
                break;
            case SubAsmNode:
                children[i]->AnalyzeData(data);
                break;
            case FileNode:    
                if(data.FindFileNode(children[i]->GetName())!=NULL)//已经含有该文件夹节点
                {
                    children[i]->AnalyzeData(data);
                }
                else
                {
                    data.AddFileNode(children[i]->GetName());
                    children[i]->AnalyzeData(data);
                }
                break;
            case PartNode:
                {
                    FileData * fileNode = data.FindFileNode(name);
                    fileNode->AddPart(children[i]->GetName());
                }
                    break;
            default:
                break;
            }
        }

    }
    void AddChildNode(TreeNode *node)
    {
        children.push_back(node);
        node->SetParent(this);
    }
    const vector<TreeNode*> GetChildren()
    {
        return children;
    }
    const TreeNode* GetParent()
    {
        return parent;
    }
    const NodeType GetNodeType()
    {
        return nodeType;
    }
    const string GetName()
    {
        return name;
    }
    void SetName(string &s)
    {
        name = s;
    }
    void SetNodeType(NodeType &type)
    {
        nodeType = type;
    }
    void SetParent(TreeNode* p)
    {
        parent = p;
    }
    void SetChildren(vector<TreeNode*> &c)
    {
        children = c;
    }
    TreeNode(string s ,NodeType t)
    {
        SetName(s);
        SetNodeType(t);
    }
    TreeNode()
    {
        children.clear();
        parent = NULL;
    }
    ~TreeNode(){}
};

测试：

int main()
{
    TreeNode asmRoot =  TreeNode("TopAsm",TopAsmNode);
    TreeNode asmSub01 =  TreeNode("asmSub01", SubAsmNode);
    TreeNode asmSub02 =  TreeNode("asmSub02", SubAsmNode);
    TreeNode fileNode01 =  TreeNode("工序1", FileNode);
    TreeNode fileNode01_2 =  TreeNode("工序1", FileNode);
    TreeNode fileNode02 =  TreeNode("工序2", FileNode);
    TreeNode part01 =  TreeNode("partA", PartNode);
    TreeNode part02 =  TreeNode("partB", PartNode);
    TreeNode part03 =  TreeNode("partC", PartNode);
    TreeNode part04 =  TreeNode("partD", PartNode);

    fileNode01.AddChildNode(&part01);
    fileNode01.AddChildNode(&part03);

    fileNode02.AddChildNode(&part04);

    fileNode01_2.AddChildNode(&part01);
    fileNode01_2.AddChildNode(&part02);

    asmSub01.AddChildNode(&fileNode01);
    asmSub01.AddChildNode(&fileNode02);
    asmSub02.AddChildNode(&fileNode01_2);

    asmRoot.AddChildNode(&asmSub01);
    asmRoot.AddChildNode(&asmSub02);

    NodeDataVec data;
    asmRoot.AnalyzeData(data);

    return 0;
}