dl_tree.h

浏览该文件的文档.

#pragma once
 
#include <vector>
#include <list>
#include <functional>
#include <unordered_map>
#include <cassert>
 
#include "io/dl_log.h"
 
namespace dl
{

template<typename T>
class NTree
{
public:
    class Node
    {
        friend class NTree<T>;
    public:
        Node(const T& v, Node* parent) :
            _parent{ parent },
            _v{v}
        {}
 
        T& GetValue() { return _v; }
        const T& GetValue() const { return _v; }
        Node* GetParent() { return _parent; }
        const Node* GetParent() const { return _parent; }
        std::vector<Node*>& GetChild() { return _child; }
        const std::vector<Node*>& GetChild() const { return _child; }
    private:
        T _v;
        Node* _parent;
        std::vector<Node*> _child;
    };
 
    NTree()
    {}

    Node* AddRoot(const T& v)
    {
        if (!_allNode.empty())
        {
            log_err0("根节点已经存在，不能重复添加！");
            return nullptr;
        }
        Node* node = new Node(v, nullptr);
        _allNode.push_back(node);
        return node;
    }

    Node* Add(const T& v, Node* node_parent)
    {
        if (!node_parent)
        {
            return AddRoot(v);
        }
        Node* node = new Node(v, node_parent);
        _allNode.push_back(node);
        node_parent->_child.push_back(node);
        return node;
    }
    Node* Add(const T& v, const T& parent)
    {
        Node* node_parent = Get(parent);
        if (!node_parent)
        {
            log_err0("父节点不存在！");
            return nullptr;
        }
        return Add(v, node_parent);
    }

    Node* PushBack(const T& v)
    {
        if (_allNode.empty())
        {
            return AddRoot(v);
        }
        Node* node_parent = _allNode.front();
        Node* node = new Node(v, node_parent);
        _allNode.push_back(node);
        node_parent->_child.push_back(node);
        return node;
    }

    bool Del(Node* node)
    {
        auto iter = std::find(_allNode.begin(), _allNode.end(), node);
        if (iter == _allNode.end())
        {
            log_err0("节点不存在！");
            return false;
        }
        // 从父节点移除
        auto iter1 = std::find(node->_parent->_child.begin(), node->_parent->_child.end(), node);
        if (iter1 == node->_parent->_child.end())
        {
            log_err0("父节点引用错误！");
            return false;
        }
        node->_parent->_child.erase(iter1);
 
        // 自己子节点连接到自己父节点
        for (Node* node_child : node->_child)
        {
            node->_parent->_child.push_back(node_child);
            node_child->_parent = node->_parent;
        }
 
        // 从主列表移除
        delete node;
        _allNode.erase(iter);
        return true;
    }

    Node* Get(T v)
    {
        for (Node* node : _allNode)
        {
            if (v == node->_v)
                return node;
        }
        return nullptr;
    }

    bool Has(Node* node)
    {
        for (Node* iter : _allNode)
        {
            if (iter == node)
                return true;
        }
        return false;
    }

    void SetParent(Node* node, Node* parent)
    {
        if (!parent)
        {
            log_err0("parent不能为空！");
            return;
        }
        if (!node->_parent)
        {
            log_err0("自己不能为空节点！");
            return;
        }
 
        if (!Has(node))
        {
            log_err0("节点不存在！");
            return;
        }
        if (!Has(parent))
        {
            log_err0("parent节点不存在！");
            return;
        }
        auto& vec_child = node->_parent->GetChild();
        auto iter_child = std::find(vec_child.begin(), vec_child.end(), node);
        if (iter_child == vec_child.end())
        {
            log_err0("旧parent不包含自身！");
            return;
        }
        vec_child.erase(iter_child);
        parent->_child.push_back(node);
        node->_parent = parent;
    }

    template<typename F>
    void ForEach(F func)
    {
        if (_allNode.empty())
            return;
 
        std::stack<Node*> s;
        s.push(_allNode.front());
 
        while (!s.empty())
        {
            Node* node_this = s.top();
            s.pop();
            func(node_this->_v);
 
            // 反向遍历
            auto& c = node_this->_child;
            for (auto iter = c.rbegin(); iter != c.rend(); ++iter)
            {
                Node* node = *iter;
                s.push(node);
            }
        }
    }
    //std::function<void(const T1&, T&)> func
    template<typename T1, typename F>
    void Copy(const NTree<T1>& b, F func)
    {
        using NodeSelf = NTree<T>::Node;
        using NodeOther = NTree<T1>::Node;
 
        // 先清空
        for (NodeSelf* node : _allNode)
        {
            delete node;
        }
        _allNode.clear();
 
        // 指针映射表
        std::unordered_map<const NodeOther*, NodeSelf*> map_ptr;
        // 构建Node，并生成 指针映射表
        for (const NodeOther* node_b : b.GetAll())
        {
            NodeSelf* node = new NodeSelf(0, nullptr);
            _allNode.push_back(node);
 
            map_ptr[node_b] = node;
        }
        // 构建 数据
        for (const NodeOther* node_b : b.GetAll())
        {
            NodeSelf* node = map_ptr[node_b];
            node->_parent = map_ptr[node_b->GetParent()];
            for (auto& iter : node_b->GetChild())
            {
                node->_child.push_back(map_ptr[iter]);
            }
            func(node_b->GetValue(), node->_v);
        }
    }

    const std::list<Node*>& GetAll() const
    {
        return _allNode;
    }

    const Node* GetRoot() const
    {
        if (_allNode.empty())
            return nullptr;
        return _allNode.front();
    }

    size_t GetSize() const
    {
        return _allNode.size();
    }

    auto begin() { return _allNode.begin(); }
    auto end() { return _allNode.end(); }
 
 
    ~NTree()
    {
        for (Node* node : _allNode)
        {
            delete node;
        }
    }
private:
    std::list<Node*> _allNode;//所有节点，第一个为根节点
};
 

//template<typename T>
//class NTreeVec
//{
//public:
//  NTreeVec(const NTree<T>& tree)
//  {
//      _node.resize(tree.GetSize());
//      size_t i = 0;
//      tree.ForEach([](const T v) {
//          _node
//          });
//  }
//private:
//  std::vector<T> _node;
//  std::vector<size_t> _parent;
//};
 
 
}