树的存储结构

文章目录

• • @[toc]
• 树结构存储方案深度解析：从理论到工业实践
• • 树结构存储方案对比全景图
  • 一、双亲表示法（Parent-Only Representation）
  • • 🛠 存储结构实现（C++优化版）
    • 性能特征
    • 典型应用场景
  • 二、孩子表示法（Children List Representation）
  • • 🛠 存储结构实现（C++智能指针版）
    • 性能特征
    • 典型应用场景
  • 三、孩子兄弟表示法（Left-Child Right-Sibling）
  • • 存储结构实现（C++模板化实现）
    • 存储结构示意图
    • 性能特征
    • 典型应用场景
  • 四、工业级存储方案选择指南
  • • 1. 决策矩阵
    • 2. 混合方案实践
    • 3. 内存优化技巧
  • 五、前沿发展与扩展阅读

树结构存储方案深度解析：从理论到工业实践

树结构存储方案对比全景图

一、双亲表示法（Parent-Only Representation）

🛠 存储结构实现（C++优化版）

#include <vector>
using namespace std;

struct ParentTreeNode {
    int data;
    int parent = -1;  // -1表示根节点
};

class ParentTree {
private:
    vector<ParentTreeNode> nodes;  // 动态数组存储
    int root = -1;                 // 根节点索引
    
public:
    // 构造函数初始化根节点
    ParentTree(int rootData) {
        nodes.emplace_back({rootData, -1});
        root = 0;
    }

    // 添加子节点
    void addChild(int parentIdx, int data) {
        if(parentIdx >= nodes.size()) return;
        nodes.emplace_back({data, parentIdx});
    }

    // 查找父节点 O(1)
    int getParent(int idx) const {
        return (idx < nodes.size()) ? nodes[idx].parent : -1;
    }
};

性能特征

典型应用场景

1. 文件系统目录结构（快速定位上级目录）
2. 组织架构树（快速获取直接上级）
3. 并查集（Union-Find）数据结构

二、孩子表示法（Children List Representation）

🛠 存储结构实现（C++智能指针版）

#include <vector>
#include <memory>
using namespace std;

struct ChildNode {
    int index;
    shared_ptr<ChildNode> next = nullptr;
};

struct TreeNode {
    int data;
    shared_ptr<ChildNode> firstChild = nullptr;
};

class ChildrenTree {
private:
    vector<TreeNode> nodes;
    int root = 0;

    // 递归释放子节点内存
    void clearChildren(shared_ptr<ChildNode>& node) {
        if(node) {
            clearChildren(node->next);
            node.reset();
        }
    }

public:
    ChildrenTree(int rootData) {
        nodes.emplace_back(TreeNode{rootData});
    }

    ~ChildrenTree() {
        for(auto& node : nodes) {
            clearChildren(node.firstChild);
        }
    }

    // 添加子节点 O(1)
    void addChild(int parentIdx, int data) {
        if(parentIdx >= nodes.size()) return;
        
        // 添加新节点
        int newIdx = nodes.size();
        nodes.emplace_back(TreeNode{data});
        
        // 更新子链表
        auto newChild = make_shared<ChildNode>(ChildNode{newIdx});
        newChild->next = nodes[parentIdx].firstChild;
        nodes[parentIdx].firstChild = newChild;
    }
};

性能特征

e表示边数，n表示节点数

典型应用场景

1. DOM树结构（频繁操作子元素）
2. 多级菜单系统
3. 家谱树可视化

三、孩子兄弟表示法（Left-Child Right-Sibling）

存储结构实现（C++模板化实现）

template <typename T>
struct CSNode {
    T data;
    unique_ptr<CSNode> firstChild;  // 左孩子指针
    unique_ptr<CSNode> nextSibling; // 右兄弟指针

    CSNode(T val) : data(val), firstChild(nullptr), nextSibling(nullptr) {}
};

template <typename T>
class CSTree {
private:
    unique_ptr<CSNode<T>> root;

    // 递归插入子节点
    void insertChild(CSNode<T>* parent, T value) {
        auto newNode = make_unique<CSNode<T>>(value);
        if(!parent->firstChild) {
            parent->firstChild = move(newNode);
        } else {
            auto current = parent->firstChild.get();
            while(current->nextSibling) {
                current = current->nextSibling.get();
            }
            current->nextSibling = move(newNode);
        }
    }

public:
    CSTree(T rootValue) {
        root = make_unique<CSNode<T>>(rootValue);
    }

    // 添加子节点 O(k) k为当前子节点数
    void addChild(CSNode<T>* parent, T value) {
        if(parent) insertChild(parent, value);
    }

    // 层次遍历示例
    void levelOrder() {
        queue<CSNode<T>*> q;
        q.push(root.get());
        
        while(!q.empty()) {
            auto node = q.front();
            q.pop();
            
            cout << node->data << " ";
            
            auto child = node->firstChild.get();
            while(child) {
                q.push(child);
                child = child->nextSibling.get();
            }
        }
    }
};

存储结构示意图

性能特征

典型应用场景

1. 树与二叉树相互转换
2. XML文档解析
3. 表达式树处理

四、工业级存储方案选择指南

1. 决策矩阵

2. 混合方案实践

// 组合双亲表示法与孩子兄弟法的混合结构
struct HybridNode {
    int data;
    int parent = -1;
    unique_ptr<HybridNode> firstChild;
    unique_ptr<HybridNode> nextSibling;
};

3. 内存优化技巧

• 内存池预分配：使用对象池减少动态分配开销
• 位压缩存储：利用联合体压缩指针空间

  union CompactPointer {
      int parentIdx;
      ChildNode* firstChild;
  };
  

五、前沿发展与扩展阅读

1. 持久化树结构：研究不可变树结构的高效存储
2. 分布式树存储：研究跨节点的树结构分片方案
3. GPU加速遍历：利用CUDA实现大规模树结构并行处理

建议：在工程实践中，建议通过Profile工具分析实际访问模式，再选择存储方案。例如高频父访问+低频子操作可选择双亲表示法，反之则选孩子兄弟法。