二叉树的实现

于 2017-05-30 09:56:01 发布
阅读量225 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KOwzb/article/details/72808695
版权
#include<iostream>
using  namespace  std;
#include<queue>
#include<stack>
template < class  T>
struct  BinaryTreeNode //节点
{
     BinaryTreeNode( const  T& x) //构造函数
         :_data(x)
         ,_left(NULL)
         ,_right(NULL)
     {}
     T _data;
     BinaryTreeNode<T>* _left;
     BinaryTreeNode<T>* _right;
};
template < class  T>
class  BinaryTree
{
public :
     BinaryTree() //构造函数
         :_root(NULL) //根节点赋空值
     {}
     
     BinaryTree( const  T* a, size_t  size) //建立二叉树
     {
         size_t  index=0;
         _root=_CreatTree(a,index,size);
     }
     ~BinaryTree() //析构
     {
         Destroy();
     }
     BinaryTreeNode<T>* Copy()
     {
         return  _Copy(_root);
     }
     BinaryTreeNode<T>* Destroy() //删除二叉树
     {
        return  _Deatroy(_root);
     }
     void  PrevOrder() //前序遍历
     {
        _PrevOrder(_root);
        cout<<endl;
     }
     void  InOrder() //中序遍历
     {
        _InOrder(_root);
        cout<<endl;
     }
     void  PostOrder() //后序遍历
     {
        _PostOrder(_root);
        cout<<endl;
     }  
     void  LevelOrder() //层次遍历
     {
         _LevelOrder(_root);
         cout<<endl;
     }
     int  Size() //计算大小
     {
          return  _Size(_root);
          cout<<endl;
     }
     int  LeafNum() //叶子节点个数
     {
          return  _LeafNum(_root);
          cout<<endl;
     }
     int  Hight() //计算二叉树高度
     {
         return  _Hight(_root);
     }
     void  PrevOrder_Non_R() //非递归前序遍历
     {
          _PrevOrder_Non_R(_root);
          cout<<endl;
     }
     void  InOrder_Non_R() //非递归中序遍历
     {
           _InOrder_Non_R(_root);
           cout<<endl;
     }
     void  PostOrder_Non_R() //非递归后序遍历
     {
           _PostOrder_Non_R(_root);
           cout<<endl;
     }
protected :
     BinaryTreeNode<T>* _CreatTree( const  T* a, size_t & index, size_t  size) //创建二叉树
     {
          BinaryTreeNode<T>* root=NULL;
          if (index<size&&a[index]!= '#' )
          {
              root= new  BinaryTreeNode<T>(a[index]); //先序创建根节点
              root->_left=_CreatTree(a,++index,size); //递归创建左节点
              root->_right=_CreatTree(a,++index,size); //递归创建右节点
          }
          return  root;
     }
     void  _PrevOrder(BinaryTreeNode<T>* root)
     {
         if (root==NULL)
         {
             return ;
         }
         else
         {
             cout<<root->_data<< " " ;
            _PrevOrder(root->_left );
            _PrevOrder(root->_right );
         }
     }
     void  _InOrder(BinaryTreeNode<T>* root)
     {
        if (root==NULL)
        {
           return ;
        }
       else
        {
           _InOrder(root->_left );
           cout<<root->_data << " " ;
           _InOrder(root->_right );
        }
     }
     void  _PostOrder(BinaryTreeNode<T>* root)
     {
         if (root==NULL)
             return ;
         else
         {
             _PostOrder(root->_left );
             _PostOrder(root->_right );
             cout<<root->_data << " " ;
         }
     }
     void  _LevelOrder(BinaryTreeNode<T>* root) //队列的使用
     {
        queue<BinaryTreeNode<T>*> q;
        q.push(root);
        while (root)
        {
            cout<<root->_data << " " ;
            if (!q.empty())
            {
               BinaryTreeNode<T>* front =q.front();
               q.pop();
               q.push(front->_left );
               q.push(front->_right );
            }
            root=q.front();
        }
     }
     int  _Size(BinaryTreeNode<T>* root)
     {
         if (root==NULL)
             return  0;
         return   _Size(root->_left )+_Size(root->_right )+1;
     }
     int  _LeafNum(BinaryTreeNode<T>* root)
     {
         if (root==NULL)
             return  0;
         if ((root->_left ==NULL)&&(root->_right ==NULL))
             return  1;
         
         return  _LeafNum(root->_left )+_LeafNum(root->_right );
     }
     int  _Hight(BinaryTreeNode<T>* root)
     {
         if (root==NULL)
             return  0;
         if (_Hight(root->_left) >_Hight(root->_right ))
         {
             return   _Hight(root->_left )+1;
         }
         else
         {
              return  _Hight(root->_right )+1;
         }
     }
     BinaryTreeNode<T>* _Copy(BinaryTreeNode<T>* root)
     {
         if (root==NULL)
             return  NULL;
         else
         {
             BinaryTreeNode<T>* r= new  BinaryTreeNode<T>(root->_data );
             BinaryTreeNode<T>* left=_Copy(root->_left );
             BinaryTreeNode<T>* right=_Copy(root->_right );
             return  r;
         }
     }
     BinaryTreeNode<T>* _Deatroy(BinaryTreeNode<T>*& root)
     {
        if (root!=NULL)
        {
            _Destroy(root->_left );
            _Deatroy(root->_right );
            delete  root;
            root=NULL;
        }
        return  root;
     }
     void   _PrevOrder_Non_R(BinaryTreeNode<T>* root)
     {
         BinaryTreeNode<T>* cur=root;
         stack<BinaryTreeNode<T>*> s;
         while (cur!=NULL||!s.empty ())
         {
             while (cur!=NULL)
             {
                  cout<<cur->_data << " " ;
                  s.push(cur);
                  cur=cur->_left ;
             }
             if (!s.empty ())
             {
                  cur=s.top();
                  s.pop();
                  cur=cur->_right ;
             }
         }      
     }
     void   _InOrder_Non_R(BinaryTreeNode<T>* root)
     {
         BinaryTreeNode<T>* cur=root;
         stack<BinaryTreeNode<T>*> s;
         while (cur!=NULL||!s.empty ())
         {
             while (cur!=NULL)
             {
                  s.push(cur);
                  cur=cur->_left ;
             }
             if (!s.empty ())
             {
                  cur=s.top();
                  cout<<cur->_data << " " ;
                  s.pop();
                  cur=cur->_right ;
             }
         }      
     }
     void  _PostOrder_Non_R(BinaryTreeNode<T>* root)
     {
         BinaryTreeNode<T>* cur=NULL;
         BinaryTreeNode<T>* temp=NULL;
         stack<BinaryTreeNode<T>*> s;
         s.push(root);
         while (!s.empty ())
         {
             cur=s.top();
             if ((cur->_left ==NULL && cur->_right ==NULL)||
                 (temp!=NULL && (temp==cur->_left||temp==cur->_right)))
             {
                cout<<cur->_data << " " ;
                s.pop();
                temp=cur;
             }
             else
             {
                 if (cur->_right !=NULL)
                 {
                    s.push(cur->_right );
                 }
                 if (cur->_left !=NULL)
                 {
                     s.push(cur->_left );
                 }
             }
         }      
     }
protected :
     BinaryTreeNode<T>* _root;
};
KOwzb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树实现
菜鸟哆哆的专栏
07-25 1260
本文内容：二叉树的数据结构、 二叉树的三种遍历赋值（先序、中序、后序）、 二叉树非递归先序遍历、 二叉树的层次遍历、 二叉树的按行打印。 一、二叉树的数据结构 二叉树包括三个元素和一个构造函数。 ...
二叉树 实现
yhhwatl的专栏
09-13 1187
//BiTNode.h 二叉链表结点类型结构体 #ifndef _yhhBITNODE_H_ #define _yhhBITNODE_H_ templatestruct BiTNode {  T data;  BiTNode *lchild, *rchild; }; #endif   //BiTree.h 二叉链表结构的二叉树类（BiTree类） #ifndef _yhhBI
重温数据结构：二叉树的常见方法及三种遍历方式 Java 实现
热门推荐
张拭心的博客 shixinzhang
11-17 2万+
读完本文你将了解到： 什么是二叉树 Binary Tree 两种特殊的二叉树 满二叉树 完全二叉树 满二叉树 和 完全二叉树 的对比图 二叉树的实现 用 递归节点实现法左右链表示法 表示一个二叉树节点 用 数组下标表示法 表示一个节点 二叉树的主要方法 二叉树的创建 二叉树的添加元素 二叉树的删除元素 二叉树的清空 获得二叉树的高度 获得二叉树的节点数 获得某个节点的父亲节点 二叉树的遍历 先序遍历
二叉树实现简易计算器
10-10
由键盘输入一算术表达式，以中缀形式输入，试编写程序将中缀表达式转换成一棵二叉表达式树，通过对该的后序遍历求出计算表达式的值。 基本要求： a．要求对输入的表达式能判断出是否合法。不合法要有错误提示信息...
基于二叉链表的二叉树实现
01-12
基于二叉链表的二叉树实现：依据最小完备性和常用性相结合的原则，以函数形式定义了二叉树的创建二叉树、销毁二叉树、清空二叉树、判定空二叉树和求二叉树深度等14种基本运算。依据最小完备性和常用性相结合的原则，...
java 二叉树实现类
最新发布
05-09
Java的二叉树实现类，是一种常见的数据结构和算法基础。在程序设计中，二叉树广泛应用于搜索、排序、储存、压缩、编码等方面，具有较高的实用价值和研究价值。 Java的二叉树实现可以采用多种方式，例如：链式存储、数组存储、堆存储等。其中，链式存储是一种常见的实现方式，其基本思想是使用节点类来表示树的结构，在每个节点类中保存左子树和右子树的引用信息。 具体实现时，需要定义一个Node类表示一个节点，该类中包含三个属性：data存储节点数据、left存储左子节点的引用、right存储右子节点的引用。通过使用Node类，便可以实现二叉树的遍历、插入、删除、查找等基本操作。 在实现Java的二叉树时，需要注意以下几点：首先，需要定义二叉树的根节点，并在每次操作后实时更新根节点的引用；其次，需要考虑二叉树的节点数据类型，如果节点数据类型不同，则需要使用泛型来处理；最后，需要结合具体应用场景，来灵活运用不同的遍历算法和数据结构，实现高效和优化的代码逻辑。 总之，Java的二叉树实现类虽然简单，但实际应用中却有着广泛的应用。通过深入理解二叉树的基本概念和常见实现方法，可以提高程序设计水平和算法思维能力，为实现更加复杂和高级的数据结构和算法奠定坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值