C++ - 二叉树template实现

已于 2022-12-19 18:39:55 修改
阅读量188 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ java 开发语言
于 2022-12-19 18:39:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45919985/article/details/128376287
版权

BinaryTree.h

#ifndef BINARYTREE_H
#define BINARYTREE_H

#include <iostream>

template <typename valType>
class BinaryTree;

template <typename valType>
class BTnode
{
    friend class BinaryTree<valType>;

public:
    BTnode(const valType &);
    // ~BTnode();

    // 小于根节点的所有数值都放在根节点的左子树，
    // 每个数值只能在树中出现一次。
    void insert_value(const valType &);
    // 搬移左子节点，使其成为右子节点的左子树的叶节点。
    static void lchild_leaf(BTnode *leaf, BTnode *subtree);
    // 将被删除的值val，指向目前关注的节点的父节点的指针prev。
    // 以pointer来传递，我们能够更改的是该pointer所指之物，
    // 而不是pointer本身。
    // 为了改变pointer本身，我们必须再加一层间接性。
    void remove_value(const valType &val, BTnode *&prev);
    // 先序遍历
    void preorder(BTnode *pt, std::ostream &os) const;
    // 中序遍历
    void inorder(BTnode *pt, std::ostream &os) const;
    // 后序遍历
    void postorder(BTnode *pt, std::ostream &os) const;

    void display_val(BTnode *pt, std::ostream &os) const
    {
        os << pt->_val << " ";
    }

private:
    valType _val;
    int _cnt;
    BTnode *_lchild;
    BTnode *_rchild;
};

template <typename elemType>
class BinaryTree
{
public:
    BinaryTree();
    BinaryTree(const BinaryTree &);
    ~BinaryTree();
    BinaryTree &operator=(const BinaryTree &);
    friend std::ostream &
    operator<<(std::ostream &os, const BinaryTree<elemType> &bt)
    {
        os << "Tree: " << std::endl;
        bt.print(os);
        return os;
    }

    // 判断二叉树是否为空。
    bool empty() { return _root == 0; }
    // 清空二叉树。
    void clear()
    {
        if (_root)
        {
            clear(_root);
            _root = 0;
        }
    }
    // 将新值插入二叉树中。
    void insert(const elemType &);
    // 移除某值。
    void remove(const elemType &);
    // 移除根节点。
    void remove_root();
    // 前序遍历
    void preorder() const
    {
        if (_root)
        {
            std::cout << "preorder: ";
            _root->preorder(_root, std::cout);
            std::cout << std::endl;
        }
    }

private:
    void print(std::ostream &os) const
    {
        if (_root)
        {
            _root->preorder(_root, os);
            os << std::endl;
        }
    }
    void clear(BTnode<elemType> *);
    // BTnode必须以template parameter list加以限定。
    BTnode<elemType> *_root;
    // 将src所指子树（subtree）复制到tar所指子树。
    void copy(BTnode<elemType> *tar, BTnode<elemType> *src);
};

#endif

main.cpp

#include <iostream>
#include <string>
#include "BinaryTree.h"

int main()
{
    BinaryTree<std::string> bt;

    bt.insert("Piglet");
    bt.insert("Eeyore");
    bt.insert("Roo");
    bt.insert("Tigger");
    bt.insert("Chris");
    bt.insert("Pooh");
    bt.insert("Kanga");
    std::cout << bt << std::endl;

    std::cout << "Preorder traversal: \n";
    bt.preorder();

    bt.remove("Piglet");
    std::cout << "\nPreorder traversal after Piglet removal: \n";
    bt.preorder();

    bt.remove("Eeyore");
    std::cout << "\nPreorder traversal after Eeyore removal: \n";
    bt.preorder();

    return 0;
}

template <typename elemType>
inline BinaryTree<elemType>::
    BinaryTree() : _root(0)
{
    std::cout << "BinaryTree constructor" << std::endl;
}

template <typename elemType>
inline BinaryTree<elemType>::
    BinaryTree(const BinaryTree &rhs)
{
    std::cout << "BinaryTree constructor" << std::endl;
    copy(_root, rhs._root);
}

template <typename elemType>
inline BinaryTree<elemType>::
    ~BinaryTree()
{
    std::cout << "BinaryTree destructor" << std::endl;
    clear();
}

template <typename elemType>
inline BinaryTree<elemType> &
BinaryTree<elemType>::
operator=(const BinaryTree &rhs)
{
    if (this != &rhs)
    {
        clear();
        copy(_root, rhs._root);
    }
    return *this;
}

template <typename elemType>
inline void
BinaryTree<elemType>::
    insert(const elemType &elem)
{
    if (!_root)
        _root = new BTnode<elemType>(elem);
    else
        _root->insert_value(elem);
}

template <typename elemType>
inline void
BinaryTree<elemType>::
    remove(const elemType &elem)
{
    if (_root)
    {
        if (_root->_val == elem)
            remove_root(); // 根节点的移除操作以特例处理。
        else
            _root->remove_value(elem, _root);
    }
}

template <typename elemType>
void BinaryTree<elemType>::
    remove_root()
{
    // 如果根节点不存在，直接返回。
    if (!_root)
        return;

    BTnode<elemType> *tmp = _root;
    // 如果右孩子存在。
    if (_root->_rchild)
    {
        _root = _root->_rchild;

        // 如果根节点的左孩子存在。
        if (tmp->_lchild)
        {
            // 根节点的左孩子。
            BTnode<elemType> *lc = tmp->_lchild;
            // 根节点右孩子的左孩子。
            BTnode<elemType> *rlc = _root->_lchild;

            // 如果rlc不存在，则lc为rlc。
            if (!rlc)
                _root->_lchild = lc;
            else
            {
                //  将左子树搬到右孩子的左子树底部。
                BTnode<elemType>::lchild_leaf(lc, rlc);
            }
        }
    }
    else
        _root = _root->_lchild;

    // 删除根节点。
    delete tmp;
}

template <typename elemType>
void BinaryTree<elemType>::
    clear(BTnode<elemType> *pt)
{
    if (pt)
    {
        clear(pt->_lchild);
        clear(pt->_rchild);
        delete pt;
    }
}

template <typename valType>
void BTnode<valType>::
    preorder(BTnode *pt, std::ostream &os) const
{
    if (pt)
    {
        display_val(pt, os);
        if (pt->_lchild)
            preorder(pt->_lchild, os);
        if (pt->_rchild)
            preorder(pt->_rchild, os);
    }
}

template <typename valType>
void BTnode<valType>::
    remove_value(const valType &val, BTnode *&prev)
{
    if (val < _val)
    {
        if (!_lchild)
            return; // 不在此二叉树。
        else
            _lchild->remove_value(val, _lchild);
    }
    else if (val > _val)
    {
        if (!_rchild)
            return; // 不在此二叉树。
        else
            _rchild->remove_value(val, _rchild);
    }
    else
    {
        // 重置该树，删除该节点。

        if (_rchild)
        {
            prev = _rchild;
            if (_lchild)
            {
                if (!prev->_lchild)
                    prev->_lchild = _lchild;
                else
                    BTnode<valType>::lchild_leaf(_lchild, prev->_lchild);
            }
        }
        else
            prev = _lchild;
        delete this;
    }
}

template <typename valType>
void BTnode<valType>::
    lchild_leaf(BTnode *leaf, BTnode *subtree)
{
    while (subtree->_lchild)
        subtree = subtree->_lchild;
    subtree->_lchild = leaf;
}

template <typename valType>
void BTnode<valType>::
    insert_value(const valType &val)
{
    if (val == _val)
    {
        ++_cnt;
        return;
    }

    if (val < _val)
    {
        // 到达叶子，创建新节点
        if (!_lchild)
            _lchild = new BTnode(val);
        else
            _lchild->insert_value(val);
    }
    else
    {
        if (!_rchild)
            _rchild = new BTnode(val);
        else
            _rchild->insert_value(val);
    }
}

// 将val以class类型对待，
// 使用copy constructor将val对象复制给_val。
template <typename valType>
inline BTnode<valType>::
    BTnode(const valType &val)
    : _val(val)
{
    _cnt = 1;
    _lchild = _rchild = 0;
}

输出结果

BinaryTree constructor
Tree:
Piglet Eeyore Chris Kanga Roo Pooh Tigger

Preorder traversal:
preorder: Piglet Eeyore Chris Kanga Roo Pooh Tigger

Preorder traversal after Piglet removal:
preorder: Roo Pooh Eeyore Chris Kanga Tigger

Preorder traversal after Eeyore removal:
preorder: Roo Pooh Kanga Chris Tigger
BinaryTree destructor
Spikeeee-
关注
专栏目录
C++-二叉树递归遍历与非递归遍历实现
席木木的博客
10-24 3618
-二叉树递归遍历与非递归遍历实现引言0 有关线性表结点定义-LinkNode1 栈的链式存储结构实现-LinkedStack2 队列的链式存储结构实现-LinkedQueue3 二叉树的链式存储结构实现3.1 树的结点定义-TreeNode3.2 二叉树定义3.3 前中后序遍历-递归算法实现3.4 前中后序遍历-非递归算法实现3.5 层序遍历算法实现4 代码测试5 测试结果 引言     二叉树的遍历方法有：前序遍历、中序遍历、后序遍历、层序遍历，其中前中后序遍历又有
C++ 数据结构学习 ---- 二叉树
qq_58240448的博客
10-23 1479
学习c++数据结构---二叉树
树模板的实现（C++）
weixin_42817333的博客
05-28 256
实现树的构造，拷贝构造，析构以及插入、删除和查找等基本功能。 树-模板的实现 #pragma once template <class T> class CMyTree_List { struct TreeNode { T data; TreeNode* pParent; TreeNode* pBrother; TreeNode* pChild; }; TreeNode* pRoot; public: CMyTree_List(); ~CMyTree_List();
2 C++ 树
qq_43153757的博客
09-02 104
目录1. 二叉树（binary tree）2. 深度优先搜索2.1 递归遍历二叉树2.2 非递归前序遍历二叉树2.3 非递归中序遍历二叉树2.4 非递归后序遍历二叉树3. 宽度优先遍历二叉树 1. 二叉树（binary tree） 数组+链表=树 数组：易于查找，不易插入删除。链表：易于插入删除，不易直接查找。 二叉树是节点度数不超过2的树。如果每个节点都是2，则是满二叉树。用二叉树表示任何一颗树。 完全二叉树：最多只有最小面的两层节点度数小于2，最小一层的结点都集中在最左边。 BinNode模板类 2.
c++利用模板实现二叉树插入删除以及遍历
M_Alan_walker的博客
07-29 242
#include <iostream> using namespace std; template <typename Type> class BinaryTree; template <typename valType> class BTnode{ friend class BinaryTree<valType>; public: BTnode(const valType &val); void insert_valu.
6、以template进行编程
伍粟的博客
05-27 359
1、类型限定 为class template定义一个inline函数，做法就像为non-template class定义一个inline函数一样;类似empty（）函数。但是在类体外，class template member function的定义语法却不一样。 template <typename elemType> class BinaryTree { public: BinaryTree(); BinaryTree( const vector< elemType >
二叉树类模板-C++实现
m0_55464171的博客
05-18 2014
二叉树是一种重要的数据结构，本文将用C++实现二叉树及其一些基本操作：遍历，插入，删除，查找…… 1）定义二叉树的模板类，并声明一些方法 template<class T> class tree { private: struct TreeNode; //树的结点 typedef TreeNode*NodePtr; static T out_of_range; //防止迭代器越界的静态变量 protected: NodePtr _root; //根结点 public: class
C++模板实现二叉树
m0_46346690的博客
11-07 450
Github完整代码下载地址 完整头文件在项目的路径为：inc/chapter6.h BinaryTree 类定义 BinaryTree类实现的二叉树能够实现以下功能： 清空二叉树 查找 插入 移除 前序(preorder)，中序（inorder），后序（postorder）的方式遍历整个二叉树 template <typename elemType> class BinaryTree{ friend class BTnode<elemType>; public:
二叉树c++模板实现
zhengzhongwu的博客
01-23 2815
二叉树c++模板实现
数据结构-二叉树的实现.docx
10-10
### 数据结构知识点：二叉树的实现 #### 实验背景与目标 本次实验的主要目的是让学生通过实际编程操作来深入理解二叉树这一重要的数据结构，并掌握其基本操作方法。二叉树是一种非常实用且常见的非线性数据结构，...
c++实验----------二叉树代码
12-28
template<class Type> class BinaryTree; template<class Type> class BinTreeNode { friend class BinaryTree; private: BinTreeNode<Type> *leftChild,*rightChild; Type data; public: BinTreeNode():...
数据结构C++——二叉树和树
最新发布
qq_60987997的博客
07-23 1089
设完全二叉树中一元素的序号为i, 1≤i≤n。，存在两个不同的二叉树，经过中序遍历都能得到这个结果。但实际上，这两颗二叉树想要实际表达的算式并不相同。与我们希望得到的最为接近。(复制、删除、输出等)。：按照树的层级，从上到下、从左到右依次遍历。：可以看作是缺少了部分元素的完全二叉树。设二叉树中元素数目为n。（前缀和后缀表达式中不会存在歧义）的次序访问树中元素，在同一层中，比如：家庭关系、公司组织……在二叉树的遍历中，每个元素。得到的表达式分别称为其的。树(tree)t是一个。实现，层次遍历通常借助。
数据结构之二叉树（类模板实现）（C++）
碣石观海的博客
05-28 3706
注：代码中使用的“ObjArrayList.h”、"SqStack.h"、"CQueue.h" 头文件代码在上三篇博文中已给出，分别为数据结构之顺序列表、栈、队列。//文件名："BiTree.h" #pragma once #ifndef BITREE_H_ #define BITREE_H_ #include &lt;string&gt; #include "ObjArrayList.h" //...
C++每日一练（类模板、树）
u012923807的博客
06-27 351
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/lxy_2011/article/details/52597515 一、今日课题 1.类模板的定义及使用 2.树的基本术语 二、实战演练 类模板 使用类模板使用户可以为类定义一种模式，使得类中的某些...
(c++) count函数用法-统计string里面出现的字符的个数
Spike的秃头之路
08-31 4598
count（begin，end，‘a’），其中begin指的是起始地址，end指的是结束地址，第三个参数指的是需要查找的字符。 返回值为str中’a’出现次数; 例如:str.size() == count(str.begin(), str.end(), ’ ') //检测是否为空行 ...
C++ - 插入迭代器（Iterator Inserter）
Spike的秃头之路
10-23 1529
插入迭代器(Insert Iterator)，又叫插入器(Inserter)。插入迭代器的主要功能为把一个赋值操作转换为把相应的值插入容器的操作。插入迭代器对标准算法库而言尤其重要。决不修改容器的大小（不插入、不删除）。有了插入迭代器，既使得算法库可以通过迭代器对容器插入新的元素，又不违反这一承诺，即保持了设计上的一致性。
C++ - 虚函数、纯虚函数与抽象类
Spike的秃头之路
10-15 1309
这为派生类提供了备用或默认的行为. C++的虚基类的虚析构函数必须提供函数体定义，否则链接时（linking）在析构该抽象类的派生实例对象的语句处会报错。
int& a (cpp学习笔记)
Spike的秃头之路
04-26 1230
int a 定义一个变量a int& a 定义一个引用 //给同一地址取别名; eg: int b ; int &a=b; 输出可知 &a = &b
C++ - 文件读写（fstream）
Spike的秃头之路
10-18 1141
如果文件名不存在，则会在当前文件目录下创建一个新文件。文件中原有数据会被清空。“outfile”返回值为布尔值，代表文件是否打开成功若文件打开成功，则文件的写入位置设定在文件的起始位置处。
C++实现先序构建二叉树详解
"本文将详细介绍如何使用C++通过先序遍历构建二叉树，并且提供四种二叉树的遍历方法：先序、中序、后序和逐层遍历。" 在C++编程中，二叉树是一种常见的数据结构，用于表示具有层次关系的数据。先序遍历是构建二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值