【数据结构】61_二叉树的存储结构设计

课程目标

完成二叉树和二叉树结点的存储结构设计

设计要点

• BTree 为二叉树结构，每个结点最多只有两个后继结点
• BTreeNode 只包含四个固定的公有成员（1数据、1前驱指针、2后驱指针）
• 实现树结构的所有操作（增，删，查，等）

BTreeNode 的设计与实现

template 
class BTreeNode : public TreeNode
{
public:
    BTreeNode *left;
    BTreeNode *right;
    
    // factory pattern
    
    // ...
};

BTree 的设计与实现

template 
class BTree : public Tree
{
    // implementation
};

BTree (二叉树结构) 的实现架构

编程实验：二叉树结构的创建

【重构】文件：TreeNode.h

#ifndef TREENODE_H
#define TREENODE_H

#include "Object.h"

namespace DTLib
{

template 
class TreeNode : public Object
{
public:
    T value;
    TreeNode *parent = nullptr;

    bool flag()
    {
        return m_flag;
    }

    virtual ~TreeNode() = 0;

protected:
    bool m_flag = false;
    
    void *operator new (unsigned int size) noexcept(true)
    {
        return Object::operator new(size);
    }
};

template 
TreeNode::~TreeNode()
{
}

}

#endif // TREENODE_H

【重构】文件:GTreeNode.h

#ifndef GTREENODE_H
#define GTREENODE_H

#include "TreeNode.h"
#include "LinkList.h"

namespace DTLib
{

template 
class GTreeNode : public TreeNode
{
public:
    LinkList*> child;

    GTreeNode() = default;

    static GTreeNode* NewNode()
    {
        GTreeNode *ret = new GTreeNode();

        if (ret != nullptr)
        {
            ret->m_flag = true;
        }

        return ret;
    }

protected:
    GTreeNode(const GTreeNode&) = default;
    GTreeNode& operator = (const GTreeNode&) = default;
};

}

#endif // GTREENODE_H

文件:BTreeNode.h

#ifndef BTREENODE_H
#define BTREENODE_H

#include "TreeNode.h"

namespace DTLib
{

template 
class BTreeNode : public TreeNode
{
public:
    BTreeNode *left = nullptr;
    BTreeNode *right = nullptr;

    static BTreeNode* NewNode()
    {
        BTreeNode *ret = new BTreeNode();

        if (ret != nullptr)
        {
            ret->m_flag = true;
        }

        return ret;
    }
};

}

#endif // BTREENODE_H

文件:BTree.h

#ifndef BTREE_H
#define BTREE_H

#include "Tree.h"
#include "BTreeNode.h"
#include "Exception.h"
#include "LinkQueue.h"

namespace DTLib
{

template 
class BTree : public Tree
{
public:
    BTree() = default;

    bool insert(TreeNode *node) override
    {
        bool ret = true;

        return ret;
    }

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

        return ret;
    }

    SharedPointer> remove(const T &value) override
    {
        return nullptr;
    }

    SharedPointer> remove(TreeNode *node) override
    {
        return nullptr;
    }

    BTreeNode* find(const T &value) const override
    {
        return nullptr;
    }

    BTreeNode* find(TreeNode *node) const override
    {
        return nullptr;
    }

    BTreeNode* root() const override
    {
        return nullptr;
    }

    int degree() const override
    {
        return 0;
    }

    int count() const override
    {
        return 0;
    }

    int height() const
    {
        return 0;
    }

    void clear() override
    {
        this->m_root = nullptr;
    }

    ~BTree()
    {
        clear();
    }

protected:
    BTree(const BTree&) = default;
    BTree& operator = (const BTree&) = default;
};

}

#endif // BTREE_H

To be continued

思考：如何实现BTree (二叉树结构) 的结点查找操作

BTreeNode* find(const T &value) const override
{
    BTreeNode *ret = nullptr;

    return ret;
}

BTreeNode* find(TreeNode *node) const override
{
    BTreeNode *ret = nullptr;

    return ret;
}