第61课 二叉树的存储结构

1. 存储结构

（1）继承关系

第61课二叉树的存储结构

（2）设计要点

　　①BTree为二叉树结构，每个结点最多只有两个后继结点

　　②BTreeNode只包含4个固定的公有成员(value、parent、left、right)

　　③实现树结构的所有操作（增、删、查等）

第61课二叉树的存储结构

2. BTreeNode的设计与实现

第61课二叉树的存储结构

（1）继承自TreeNode，内含parent、left、right指针，分别指向父结点、左孩子、右孩子结点。

（2）与通用树结点一样，提供工厂方法NewNode

（3）设置m_flag标志，用于标识结点是否存储于堆空间中。

3. BTree的设计与实现

第61课二叉树的存储结构

（1）继承自Tree

（2）内部组合使用BTreeNode

//Tree.h(重构)

#ifndef _TREE_H_
#define _TREE_H_

#include "Object.h"
#include "SharedPointer.h"
#include "Iterator.h"

namespace DTLib {

//树结点的定义
template <typename T>
class TreeNode : public Object
{
protected:
    bool m_flag; //标识结点是否位于堆空间？

    TreeNode(const TreeNode<T>&);
    TreeNode<T> & operator=(const TreeNode<T>&);

    //禁止外部手动调用new
    void* operator new(unsigned int size) throw()
    {
        return Object::operator new(size);
    }
public:
    T value;
    TreeNode<T>* parent;

    TreeNode()
    {
        parent = NULL;
        m_flag = false;
    }

    bool flag()
    {
        return m_flag;
    }

    virtual ~TreeNode() = 0;
};

template <typename T>
TreeNode<T>::~TreeNode()
{
}

//树的定义
template <typename T>
class Tree : public Object
{
public:
    typedef TreeNode<T> Node;
protected:
    Node* m_root;

    //禁止树之间的复制
    Tree(const Tree<T>&);
    Tree<T> & operator=(const Tree<T>&);

public:
    Tree(){m_root = NULL;}
    virtual bool insert(Node* node) = 0; //插入结点
    virtual bool insert(const T& value, Node* parent) = 0;
    //删除节点（注意，返回被删除的子树！）
    virtual SharedPointer<Tree<T> > remove(const T& value) = 0; //删除结点
    virtual SharedPointer<Tree<T> > remove(Node* node) = 0;
    virtual Node* find(const T& value) const = 0; //查找节点
    virtual Node* find(Node* node) const = 0;
    virtual Node* root() const = 0; //获取根结点
    virtual int degree() const = 0; //树的度
    virtual int count() const = 0;  //树的结点数目
    virtual int height() const = 0; //树的高度
    virtual void clear() = 0;       //清空树

};

//前向迭代器（树型）
template<class T, class Ref, class Ptr, class Node>
struct TreeIterator
{
    typedef TreeIterator<T, T&, T*, Node>   iterator;
    typedef TreeIterator<T, const T&, const T*, Node> const_iterator;
    typedef TreeIterator<T, Ref, Ptr, Node>   self;

    typedef ForwardIterator_tag  iterator_category; //迭代器类型
    typedef T   value_type; //值类型
    typedef Ptr pointer;    //指针类型
    typedef Ref  reference; //引用类型
    typedef ptrdiff_t difference_type;
    typedef Node*  node_type; //节点指针类型

    node_type  cursor;  //迭代器当前所指节点

    TreeIterator(node_type x) : cursor(x){}
    TreeIterator(const iterator& x) : cursor(x.cursor){}

    //重载==和!=操作符
    bool operator ==(const self& x) const
    {
        return cursor == x.cursor;
    }

    bool operator !=(const self& x) const
    {
        return cursor != x.cursor;
    }

    //重载*和->操作符
    reference operator*() const
    {
        return (*cursor).value;
    }

    pointer operator->() const
    {
        return &(operator*());
    }

};

}

#endif // _TREE_H_

//GTree.h(重构)

#ifndef _GTREE_H_
#define _GTREE_H_

#include "Tree.h"
#include "LinkList.h"
#include "Exception.h"
#include "Iterator.h"
#include "LinkQueue.h"

namespace DTLib {

//通用树结点定义
template <typename T>
class GTreeNode : public TreeNode<T>
{

public:
    LinkList<GTreeNode<T>*> childs;

    //工厂模式：要获取GTreeNode的堆空间对象，只能从这里拿
    static GTreeNode<T>* NewNode()
    {
        GTreeNode<T>* ret = new GTreeNode<T>;
        if(ret != NULL){
            ret->m_flag = true;
        }

        return ret;
    }
};

//前向迭代器（树型）
template<class T, class Ref, class Ptr, class Node>
struct GTreeIterator : public TreeIterator<T, Ref, Ptr, Node>
{
private:
    LinkQueue<Node*> m_queue;

public:

    typedef GTreeIterator<T, T&, T*, Node>   iterator;
    typedef GTreeIterator<T, const T&, const T*, Node> const_iterator;
    typedef GTreeIterator<T, Ref, Ptr, Node>   self;

    typedef ForwardIterator_tag  iterator_category; //迭代器类型
    typedef T   value_type; //值类型
    typedef Ptr pointer;    //指针类型
    typedef Ref  reference; //引用类型
    typedef ptrdiff_t difference_type;
    typedef Node*  node_type; //节点指针类型

    GTreeIterator(const node_type& x) :  TreeIterator<T, Ref, Ptr, Node>(x){m_queue.clear();m_queue.enQueue(x);}
    //前置++
    self& operator++()
    {
        this->cursor = NULL;

        if(m_queue.length() > 0 ){

            //当前结点的孩子结点进入队列中
            Node* curr = (Node*) m_queue.front();
            m_queue.deQueue();

            typename LinkList<Node*>::iterator iter = curr->childs.begin();
            while(iter != curr->childs.end())
            {
                m_queue.enQueue(*iter);
                ++iter;
            }

            if(m_queue.length() > 0 )
                this->cursor = m_queue.front();
        }

        return *this;
    }

    //后置++
    self operator++(int)
    {
        self tmp = *this;
        ++(*this);

        return tmp;
    }
};

//通用树的定义
template <typename T>
class GTree : public Tree<T>
{
public:
    typedef typename Tree<T>::Node Node;
    typedef GTreeNode<T> GNode;

protected:
    GNode* find(GNode* node, const T& value) const
    {
        GNode* ret = NULL;

        if(node != NULL){
            if(node->value == value){
                ret = node;
            }else{
                //遍历node的孩子（每个孩子结点又都是一棵子树）
                typename LinkList<GNode*>::iterator iter = node->childs.begin();
                while((iter != node->childs.end()) && (ret == NULL)){
                    ret = find(*iter, value);
                    ++iter;
                }
            }
        }

        return ret;
    }

    GNode* find(GNode* node, GNode* obj) const
    {
        GNode* ret = NULL;

        if(node == obj){
            ret = node;
        }else{
            if( node != NULL){
                //遍历node的孩子（每个孩子结点又都是一棵子树）
                typename LinkList<GNode*>::iterator iter = node->childs.begin();
                while((iter != node->childs.end()) && (ret == NULL)){
                    ret = find(*iter, obj);
                    ++iter;
                }
            }
        }

        return ret;
    }

    void free(GNode* node) //清除某个节点（含其中的子树）
    {
        if (node != NULL){
            //遍历node的孩子
            typename LinkList<GNode*>::iterator iter = node->childs.begin();
            while(iter != node->childs.end()){
                free(*iter);
                ++iter;
            }

            if(node->flag()) //只有当node是来自堆空间对象时，才需要delete
                delete node; //node释放时，childs（链表会被自动释放）
        }
    }

    void remove(GNode* node, GTree<T>*& ret)
    {
        ret = new GTree<T>();

        if(ret != NULL){
            if(root() == node){
                this->m_root = NULL;
            }else{
                LinkList<GNode*>& childs = dynamic_cast<GNode*>(node->parent)->childs;
                childs.remove(childs.find(node)); //node指针从LinkList链表中移除

                node->parent = NULL;
            }

            ret->m_root = node;

        }else{
            THROW_EXCEPTION(NotEnoughMemoryException, "No memory to create new tree...");
        }
    }

    int count(GNode* node) const
    {
        int ret = 0;

        if (node != NULL){

            ret = 1;
            typename LinkList<GNode*>::iterator iter = node->childs.begin();
            while(iter != node->childs.end()){
                ret += count(*iter);
                ++iter;
            }
        }

        return ret;
    }

    int degree(GNode* node) const
    {
        int ret = 0;

        if (node != NULL){

            ret = node->childs.length();
            typename LinkList<GNode*>::iterator iter = node->childs.begin();
            while(iter != node->childs.end()){
                int temp =  degree(*iter);

                if(ret < temp){
                    ret = temp;
                }

                ++iter;
            }
        }

        return ret;
    }

    int height(GNode* node) const
    {
        int ret = 0;

        if (node != NULL){

            typename LinkList<GNode*>::iterator iter = node->childs.begin();

            while(iter != node->childs.end()){
                int temp =  height(*iter);

                if(ret < temp){
                    ret = temp;
                }

                ++iter;
            }

            ret += 1;
        }

        return ret;
    }

public:
    GTree()
    {

    }

    bool insert(Node* node) //插入结点
    {
        bool ret = true;

        if(node != NULL){
            if(this->m_root == NULL){
                this->m_root = node;
                node->parent = NULL;
            }else{
                GNode* np = find(node->parent); //np: node parent
                if(np != NULL){
                    //查找np结点下，是否己经存在node结点？若己经存在，则不插入。
                    GNode* nd = dynamic_cast<GNode*>(node);//nd: node

                    if(np->childs.find(nd) < 0){
                        np->childs.insert(nd); //插入到链表末尾
                    }
                }else{
                    THROW_EXCEPTION(InvalidOperationException, "Invalid parent tree Node...");
                }
            }
        }else{
            THROW_EXCEPTION(InvalidParameterException, "Paramter node can't be NULL!");
        }

        return ret;
    }

    bool insert(const T& value, Node* parent)
    {
        bool ret = true;

        GNode* node = GNode::NewNode(); //new GNode();

        if(node != NULL){
            node->parent = parent;
            node->value = value;
            ret = insert(node); //调用重载的insert(Node*)函数。
        }else{
            THROW_EXCEPTION(NotEnoughMemoryException, "Not enough memory to insert new node...");
        }

        return ret;
    }

    //删除节点（注意，返回被删除的子树！）
    SharedPointer<Tree<T> > remove(const T& value) //删除结点
    {
        GTree<T>* ret = NULL;

        GNode* node = find(value);
        if(node == NULL){
            THROW_EXCEPTION(InvalidParameterException, "Parameter node is invalid...");
        }else{
            remove(node, ret);
        }

        return ret;
    }

    SharedPointer<Tree<T> > remove(Node* node)
    {
        GTree<T>* ret = NULL;
        node = find(node); //node是否在当前树中

        if(node == NULL){
            THROW_EXCEPTION(InvalidParameterException, "Can not find the node via parameter value...");
        }else{
            remove(dynamic_cast<GNode*>(node), ret);
        }

        return ret;
    }

    GNode* find(const T& value) const //查找节点
    {
        return find(root(), value);
    }

    //注意返回值由Node*改为GNode*（赋值兼容原则）
    GNode* find(Node* node) const
    {
        return find(root(), dynamic_cast<GNode*>(node));
    }

    GNode* root() const
    {
        return dynamic_cast<GNode*>(this->m_root);
    }

    int degree() const  //树的度
    {
        return degree(root());
    }

    int count() const   //树的结点数目
    {
        return count(root());
    }

    int height() const  //树的高度
    {
        return height(root());
    }

    void clear()        //清空树
    {
        free(root());
        this->m_root = NULL;
    }

    ~GTree()
    {
        clear();
    }
public:
    typedef GTreeIterator<T, T&, T*, GNode>   iterator;
    typedef GTreeIterator<T, const T&, const T*, GNode> const_iterator;

    iterator begin()
    {
        //调用GIterator(Node_type)构造函数
        return (GNode*)(this->m_root);
    }

    iterator end()
    {
        return  NULL;
    }

    const_iterator begin() const
    {
        //调用GIterator(Node_type)构造函数
        return (GNode*)(root());
    }

    virtual const iterator end() const
    {
        return  NULL;
    }
};

}

#endif // _GTREE_H_

View Code

//BTree.h

#ifndef _BTREE_H_
#define _BTREE_H_

#include "Tree.h"

namespace DTLib
{

template<typename T>
class BTreeNode : public TreeNode<T>
{
public:
    BTreeNode<T>* left;
    BTreeNode<T>* right;

    BTreeNode()
    {
        left = NULL;
        right = NULL;
    }

    //工厂模式：要获取BTreeNode的堆空间对象，只能从这里拿
    static BTreeNode<T>* NewNode()
    {
        BTreeNode<T>* ret = new BTreeNode<T>;
        if(ret != NULL){
            ret->m_flag = true;
        }

        return ret;
    }
};

template<typename T>
class BTree : public Tree<T>
{
public:
    typedef typename Tree<T>::Node Node;
    typedef BTreeNode<T> BNode;
public:
    bool insert(Node* node) //插入结点
    {
        bool ret = true;
        return ret;
    }

    bool insert(const T& value, Node* parent)
    {
        bool ret = true;
        return ret;
    }

    //删除节点（注意，返回被删除的子树！）
    SharedPointer<Tree<T> > remove(const T& value)  //删除结点
    {
        return NULL;
    }

    SharedPointer<Tree<T> > remove(Node* node)
    {
        return NULL;
    }

    BNode* find(const T& value) const //查找节点
    {
        return NULL;
    }

    BNode* find(Node* node) const
    {
        return NULL;
    }

    BNode* root() const //获取根结点
    {
        return this->m_root;
    }

    int degree() const  //树的度
    {
        return 0;
    }

    int count() const  //树的结点数目
    {
        return 0;
    }

    int height() const //树的高度
    {
        return 0;
    }

    void clear()      //清空树
    {
        this->m_root = NULL;
    }

    ~BTree()
    {
        clear();
    }
};



}

#endif // _BTREE_H_

原文链接: https://www.cnblogs.com/5iedu/p/7909178.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍;

也有高质量的技术群，里面有嵌入式、搜广推等BAT大佬

原创文章受到原创版权保护。转载请注明出处：https://www.ccppcoding.com/archives/392803

非原创文章文中已经注明原地址，如有侵权，联系删除

关注公众号【高性能架构探索】，第一时间获取最新文章

转载文章受原作者版权保护。转载请注明原作者出处！

第61课 二叉树的存储结构

相关推荐

第61课二叉树的存储结构