C++树的实现

最新推荐文章于 2024-05-26 18:52:42 发布
最新推荐文章于 2024-05-26 18:52:42 发布
阅读量3.2w 收藏 42
点赞数 3
分类专栏： C/C++ 文章标签： c++ iterator tree list delete struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stephenxu111/article/details/2446382
版权
C++树的实现
STL里面没有提供容器树的模板实现，从网上找到一个：
 
Tree.h
//tree.h 头文件
 
#include < list >
#include <algorithm>
using namespace std;
 
struct TreeNode ; // 定义一个结构体原形
class Tree ;      // 定义一个类原形
class Iterator ;  // 定义一个类原形
typedef list < TreeNode *> List ; // 重命名一个节点链表
 
TreeNode * clone ( TreeNode *, List &, TreeNode *); //Clone 复制函数
 
struct TreeNode {
   int _data ;                  // 数据
   TreeNode * _parent ;          // 父节点
   List _children ;             // 子节点
   TreeNode ( int , TreeNode *);    // 构造函数
   void SetParent ( TreeNode &);  // 设置父节点
   void InsertChildren ( TreeNode &); // 插入子节点
};
 
class Tree {
public:
 
  // 下面是构造器和运算符重载
   Tree ();                            // 默认构造函数
   Tree ( const Tree &);                 // 复制构造函数
   Tree ( const int );                   // 带参数构造函数
   Tree ( const int , const list < Tree *>&); // 带参数构造函数
   ~ Tree ();                           // 析构函数
   Tree & operator=( const Tree &);      //= 符号运算符重载
   bool operator==( const Tree &);      //== 符号运算符重载
   bool operator!=( const Tree &);      //!= 符号运算符重载
 
   // 下面是成员函数
   void Clear ();                      // 清空
   bool IsEmpty () const ;               // 判断是否为空
   int Size () const ;                   // 计算节点数目
   int Leaves ();                      // 计算叶子数
   int Root () const ;                   // 返回根元素
   int Height ();                      // 计算树的高度
 
 
   // 下面是静态成员函数
  static bool IsRoot ( Iterator );     // 判断是否是根
   static bool isLeaf ( Iterator );     // 判断是否是叶子
   static Iterator Parent ( Iterator ); // 返回其父节点
   static int NumChildren ( Iterator ); // 返回其子节点数目
 
   // 跌代器函数
   Iterator begin ();                  //Tree Begin
   Iterator end ();                    //Tree End
   friend class Iterator ;             //Iterator SubClass
private :
   list < TreeNode *> _nodes ;         // 节点数组
   list < TreeNode *>:: iterator LIt ;  // 一个节点迭代器
   int height ( TreeNode *);
   int level ( TreeNode *, Iterator );
};
 
//This is TreeSub Class Iterator
class Iterator {
   private : 
    Tree * _tree ;                     //Tree data
    list < TreeNode *>:: iterator _lit ;  //List Iterator
   public:
    Iterator ();                               // 默认构造函数
    Iterator ( const Iterator &);                // 复制构造函数
    Iterator ( Tree *, TreeNode *);                // 构造函数
    Iterator ( Tree *, list < TreeNode *>:: iterator ); // 构造函数
    // 运算符重载
    void operator=( const Iterator &);          // 赋值运算符重载
    bool operator==( const Iterator &);         // 关系运算符重载
    bool operator!=( const Iterator &);         // 关系运算符重载
    Iterator & operator++();                   // 前缀 ++ 运算符
    Iterator operator++( int );                 // 后缀 ++ 运算符
    int operator*() const ;                     // 获得节点信息
    bool operator!();                          // 赋值运算符重载
  
    typedef list < TreeNode *>:: iterator List ;
    friend class Tree ;
};
 
Tree.cpp
//tree.cpp 实现文件
 
#include "Tree.h"
 
//***** 下面是对于 TreeNode 结构体的定义实现 *****///
 
TreeNode::TreeNode( int type = 0,TreeNode* Parent = 0){
  _data = type ;
  _parent = Parent ;
}
void TreeNode:: SetParent (TreeNode& node ){
  _parent = & node ;
}
void TreeNode:: InsertChildren (TreeNode& node ){
 TreeNode* p = & node ;
  _children . push_back ( p );
}
 
 
 
//***** 下面是对于 Tree 类的定义实现 *****///
Tree :: Tree (){
 
}
 
Tree :: Tree ( const int type ){
  _nodes . push_back ( new TreeNode( type ));
}
 
Tree :: Tree ( const Tree & t ){
 if( t . _nodes . empty ())return;
  clone ( t . _nodes . front (), _nodes ,0);
}
Tree :: Tree ( const int type , const list < Tree *>& lit ){
 TreeNode* root = new TreeNode( type ); // 建立根节点
  _nodes . push_back ( root ); // 放入树中
  list < Tree *>:: const_iterator it ;
 for( it = lit . begin (); it != lit . end (); it ++){
 if(!((* it )-> _nodes . empty ())){ // 如果当前节点元素不为空
   Tree * tp = new Tree (** it );
   TreeNode* p = tp -> _nodes . front ();
   root -> _children . push_back ( p ); // 设置根的子节点
   p -> _parent = root ;            // 设置节点的父节点为根
   list <TreeNode*>:: iterator lit1 = tp -> _nodes . begin ();
   list <TreeNode*>:: iterator lit2 = tp -> _nodes . end ();
   list <TreeNode*>:: iterator lit3 = _nodes . end ();
   _nodes . insert ( lit3 , lit1 , lit2 );
 }
 }
}
 
Tree ::~ Tree (){
 for( list <TreeNode*>:: iterator it = _nodes . begin (); it != _nodes . end (); it ++){
 delete* it ;
 }
}
 
Tree & Tree ::operator =( const Tree & t ){
  Clear ();
  Tree * p = new Tree ( t );
  _nodes = p -> _nodes ;
 return *this;
}
 
bool Tree ::operator ==( const Tree & t ){
 if( _nodes . size ()!= t . _nodes . size ()){
 return false;
 }
  list <TreeNode*>:: iterator it = _nodes . begin ();
  list <TreeNode*>:: const_iterator _it = t . _nodes . begin ();
 while( it != _nodes . end ()&& _it != t . _nodes . end ()){
 if((* it )-> _data !=(* _it )-> _data ){
   return false;
 }
  it ++;
  _it ++;
 }
 return true;
}
 
bool Tree ::operator !=( const Tree & t ){
 if( _nodes . size ()!= _nodes . size ()){
 return true;
 }
 else{
  list <TreeNode*>:: iterator it = _nodes . begin ();
     list <TreeNode*>:: const_iterator _it = t . _nodes . begin ();
 while( it != _nodes . end ()&& _it != t . _nodes . end ()){
   if((* it )-> _data !=(* _it )-> _data ){
    return true;
   }
   it ++;
   _it ++;
 }
 return false;
 }
}
 
void Tree :: Clear (){
 for( list <TreeNode*>:: iterator it = _nodes . begin (); it != _nodes . end (); it ++){
 delete* it ;
 }
  _nodes . clear ();
}
 
bool Tree :: IsEmpty () const {
 return _nodes . empty ();
}
 
int Tree :: Size () const {
 return ( int ) _nodes . size ();
}
 
int Tree :: Leaves (){
  int i = 0;
  list <TreeNode*>:: iterator it = _nodes . begin ();
 while( it != _nodes . end ()){
 if((* it )-> _children . size ()==0){
   i ++;
 }
  it ++;
 }
 return i ;
}
 
 
int Tree :: Height (){
 if( _nodes . size ()!=0){
 TreeNode* TNode = _nodes . front ();
 return height ( TNode );
 }
 else{
 return -1; // 判断为空树
 }
}
 
int Tree :: height (TreeNode* node ){
 if(! node ){
 return -1;
 }
 else{
  list <TreeNode*> plist = node -> _children ;
 if( plist . size ()==0){
   return 0;
 }
  int hA = 0;
 for( list <TreeNode*>:: iterator it = plist . begin (); it != plist . end (); it ++){
   int hB = height (* it );
   if( hB > hA ){
    hA = hB ;
   }
 }
 return hA +1;
 }
}
 
 
Iterator Tree :: begin (){
 return Iterator (this, _nodes . begin ());
}
 
Iterator Tree :: end (){
 return Iterator (this, _nodes . end ());
}
int Tree :: Root () const {
 return (* _nodes . begin ())-> _data ;
}
 
 
bool Tree :: IsRoot ( Iterator it ){
 TreeNode p = * it ;
 if( p . _parent == 0){
 return true;
 }
 return false;
}
 
bool Tree :: isLeaf ( Iterator it ){
 TreeNode p = * it ;
 if( p . _children . size () == 0){
 return true;
 }
 return false;
}
 
Iterator Tree :: Parent ( Iterator it ){
 TreeNode p = * it ;
  Tree * t = it . _tree ;
  Iterator Ite ( t , p . _parent );
 return Ite ;
}
 
 
int Tree :: NumChildren ( Iterator it ){
 TreeNode p = * it ;
 return ( int ) p . _children . size ();
}
 
//***** 下面是对于 Tree::Iterator 类的定义实现 *****///
Iterator :: Iterator (){
}
 
Iterator :: Iterator ( const Iterator & it ){
  _tree = it . _tree ;
  _lit = it . _lit ;
}
 
Iterator :: Iterator ( Tree * t , TreeNode* n ){
  _tree = t ;
  list <TreeNode*>& nodes = _tree -> _nodes ;
  _lit = find ( nodes . begin (), nodes . end (), n ); //<algorithm> Members
}
 
Iterator :: Iterator ( Tree * t , list <TreeNode*>:: iterator lt ){
  _tree = t ;
  _lit = lt ;
}
 
void Iterator ::operator =( const Iterator & it ){
  _tree = it . _tree ;
  _lit = it . _lit ;
}
 
bool Iterator ::operator ==( const Iterator & it ){
 return _tree == it . _tree && _lit == it . _lit ;
}
 
bool Iterator ::operator !=( const Iterator & it ){
 return _tree != it . _tree || _lit != it . _lit ;
}
 
Iterator & Iterator ::operator ++(){
 ++ _lit ;
 return *this;
}
 
Iterator Iterator ::operator ++( int ){
  Iterator it (*this);
 ++ _lit ;
 return it ;
}
 
int Iterator ::operator *() const {
 return ((* _lit )-> _data );
}
 
bool Iterator ::operator !(){
 return _lit == _tree -> _nodes . end ();
}
 
//Clone 函数
TreeNode* clone (TreeNode* node , List & nodes ,TreeNode* nodep ){
 TreeNode* cp = new TreeNode( node -> _data , nodep );
  nodes . push_back ( cp );
  List & l = node -> _children ;
  List & cl = cp -> _children ;
 for( list <TreeNode*>:: iterator lt = l . begin (); lt != l . end (); lt ++){
  cl . push_back ( clone (* lt , nodes , cp ));
 }
 return cp ;
}
stephenxu111
关注
  • 3
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
C++ 实现trie树
weixin_44208324的博客
03-28 138
实现一个trie数，包括insert(插入单词)、search(搜索单词)、startsWith(检查是否包含前缀)。输入的字符串只包含小写字符(a-z)。 #include<vector> #include<string> #define MAX_TRIE_CHAR_NUM 26 struct TrieNode { TrieNode* child[MAX_TRIE_CH...
C++实现 排序树
weixin_42581477的博客
08-28 389
#include<iostream> using namespace std; template<typename T1> class sortTree; //根的类型 template<typename T> class node { public: //有参构造 node(T); //友元类 friend class sortTree<T&g...
C++ 树形结构
x_xx_xxx_xxxx的博客
08-29 5374
参考自：http://blog.csdn.net/stephenxu111/article/details/2446382 修改了此篇文章中 代码显示的一点小问题。///Tree.h 文件 #pragma once #include <list> #include <algorithm> using namespace std;struct TreeNode; //定义一个结构体原形 clas
数据结构——二叉树遍历及常见操作c代码实现
weixin_45491420的博客
06-28 308
二叉树遍历及常见操作代码实现。
【C++】树(Tree)
最新发布
2301_80418172的博客
05-26 790
树
c++数据结构：二叉树
sylviiiiiia的博客
10-28 828
关系约束定义：每个结点有0~n个子节点 一对多关系递归定义：子树。
c++ 头文件注意事项
weixin_46934960的博客
05-27 694
关于.cpp与.h头文件中方法命名空间冲突，unknown override specifier 例子： 在Header.h头文件中，对于string我们要声明它属于std的命名空间 而helpFunc.cpp中的string serialize(TreeNode* root){。。。}string 属于std（我们在前面使用了using namespace std:），这样就会使得该方法找不到头文件中的声明。 从而导致： 正确做法： Header.h头文件 helpFunc.cpp文件 代码呈上：
[c++] 树和二叉树
Drm123的博客
11-17 997
c++ 实现二叉树的各个操作。
C++实现西瓜书决策树
01-31
在这个"C++实现西瓜书决策树"的项目中，我们将探讨如何用C++编程语言来实现这个算法，以及相关的理论知识。 1. **决策树的基本概念** - **ID3算法**：这是最早的决策树算法，基于信息熵和信息增益来选择最优特征...
C++实现哈夫曼树算法
08-19
C++实现哈夫曼树算法 C++实现哈夫曼树算法是对哈夫曼树数据结构的实现，哈夫曼树是一种特殊的二叉树，它的每个叶子节点都带有一个权值，所有叶子节点的权值之和为1，哈夫曼树的构建是基于哈夫曼编码的原理。下面是...
四叉树quadtree的c++实现
06-06
在C++中实现四叉树，首先需要定义四叉树节点的结构。节点通常包含以下几个部分： 1. 数据域：存储每个节点所代表的区域内的点信息。 2. 四个子节点指针：分别指向上、下、左、右四个子区域的四叉树节点。 3. 存储...
C++红黑树实现过程
09-15
在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. ...
哈夫曼树c++实现
05-17
哈夫曼树
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
c++ 多叉树
01-27
在C++中实现多叉树，能够帮助我们更好地理解和操作复杂的数据结构，提升算法效率。本篇文章将深入探讨C++实现多叉树的相关知识点。 首先，多叉树是一种树形数据结构，每个节点可以有多个子节点，不同于二叉树只有左...
决策树实现iris鸢尾花分类-C++
04-28
在C++中实现决策树算法可以用于解决分类问题。在本文中，我们将介绍如何在C++中使用决策树算法来解决鸢尾花分类问题。 首先，我们需要准备鸢尾花数据集。可以从网上下载或使用机器学习库中的内置数据集，如scikit-...
C++二叉树基础 12.30
sdwsyns的博客
05-26 312
二叉树结构： struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 二叉树的遍历方式: 前序序列：根左右 (递归中常用到) 中序序列：左根右 后序序列：左右根 算法相关： （ps:原设定，一棵树只有一个节点或没有节点，它的深度都为0，而这里对于空节点的深度设定为-1，只有一个节点深度设为0） 1.计算二叉树深度 int height
C++ 二叉树常见用法
qq_37082966的博客
06-17 1775
二叉树的创建： 上篇文章遍历的时候二叉树的创建是这样的： TreeNode* T1 = new TreeNode(8); TreeNode* T2 = new TreeNode(8); TreeNode* T3 = new TreeNode(7); TreeNode* T4 = new TreeNode(9); TreeNode* T5 = new TreeNode(2); TreeNode* T6 = new TreeNode(4); TreeNode* T7 = new TreeNode(
剑指---树篇（C++）
qq_40077565的博客
01-22 7125
文章目录树篇第一题： 树篇 第一题： 题目解读： 代码部分：
C++决策树代码 一.docx
06-02
"这篇文档是关于使用C++实现决策树算法的一个示例。代码中包含了一个ID3类，用于处理决策树...为了完全理解这个决策树实现，你需要对决策树的理论有深入的理解，包括ID3算法的原理，以及如何从数据中构建和遍历树结构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值