二叉树的C++实现

最新推荐文章于 2025-03-25 18:34:36 发布
最新推荐文章于 2025-03-25 18:34:36 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 遍历 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lc331257229/article/details/46490989
版权 
#include<iostream>
using namespace std;
//二叉树节点的创建  
    template<class Type>
    class BinTreeNode
    {
        //friend class BinTree<Type>;
    public:
        BinTreeNode():data(Type()),leftChild(NULL),rightChild(NULL)
        {}
        BinTreeNode(Type d,BinTreeNode<Type> *l=NULL,BinTreeNode<Type> *r=NULL):
        data(d),leftChild(l),rightChild(r)
        {}
        ~BinTreeNode()
        {}
    private:
        Type data;
        BinTreeNode<Type> *leftChild;
        BinTreeNode<Type> *rightChild;
    };
//二叉树的创建
template <class Type>
class BinTree
{
public:
    BinTree():root(NULL)
    {}
    BinTree(Type ref):StopFlag(ref),root(NULL)
    {}
    BinTree(const BinTree<Type> &bt)
    {
        root = Copy(bt.root);
        StopFlag = bt.StopFlag;
    }
    ~BinTree()
    {
        Destroy(root);
    }
private:
    BinTreeNode<Type> *root;
    Type StopFlag;
};

//二叉树功能的实现
template<class Type>
class BinTree
{
public:
//根据中序、后序创建二叉树
    void CreateBinTreeByMidPost(BinTreeNode<Type> *&t,
                               char *LVR,
                               char *LRV,
                               int n)
    {
        if(n == 0)
            t = NULL;
        else
        {
            int i=0;
            while(LRV[n-1] != LVR[i])
            {i++;}
            t = new BinTreeNode<Type>(LVR[i]);
            CreateBinTreeByMidPost(t->rightChild,LVR+i+1,LRV+i,n-1-i);
            CreateBinTreeByMidPost(t->leftChild,LVR,LRV,i);

    }
}
//根据前序、中序创建二叉树
void CreateBinTreeByPreMid(BinTreeNode<Type> *&t,
                           char *VLR,
                           char *LVR,
                           int n)
{
    if(n == 0)
        t = NULL;
    else
    {
        int i=0;
        while(VLR[0] != LVR[i])
        {
            i++;
        }
        t = new BinTreeNode<Type>(LVR[i]);
        CreateBinTreeByPreMid(t->leftChild,VLR+1,LVR,i);
        CreateBinTreeByPreMid(t->rightChild,VLR+i+1,LVR+i+1,n-i-1);
    }

}
//求深度
    int Height(BinTreeNode<Type> *t)const
    {
        if(!t)
         return 0;
        int len1=Height(t->leftChild);
        int len2=Height(t->rightChild);
        return len1>len2 ? (len1+1) :(len2+1);
    }
//二叉树元素的个数
int Size(BinTreeNode<Type> *t)const
{
    if(t == NULL)
        return 0;
    else
    {
        return Size(t->leftChild)+Size(t->rightChild)+1;
    }
}
//判等
bool Equal(BinTreeNode<Type> *t1,BinTreeNode<Type> *t2)
{
    if(t1==NULL && t2==NULL)
        return true;
    else if(t1!=NULL && t2!=NULL
            && t1->data==t2->data
            && Equal(t1->leftChild,t2->leftChild)
            && Equal(t1->rightChild,t2->rightChild))
            return true;
    else
        return false;
}
//拷贝
BinTreeNode<Type>* Copy(BinTreeNode<Type> *t)
{
    if(t == NULL)
        return NULL;
    else
    {
        BinTreeNode<Type> *s = new   BinTreeNode<Type>(t->data);
        s->leftChild = Copy(t->leftChild);
        s->rightChild = Copy(t->rightChild);
        return s;
    }
}
//求父节点
BinTreeNode<Type>* Parent(BinTreeNode<Type> *t,BinTreeNode<Type> *p)
{
    if(t==NULL || p==NULL)
        return NULL;
    if(t->leftChild==p || t->rightChild==p)
        return t;
    else
    {
        //
        BinTreeNode<Type> *q = Parent(t->leftChild,p);
        if(q != NULL)
            return q;
        return Parent(t->rightChild,p);
    }
}
//查找二叉树的元素
BinTreeNode<Type>* Find(BinTreeNode<Type>*t,Type key)
{
    if(t==NULL)
        return NULL;
    if(t->data == key)
        return t;
    else
    {
        BinTreeNode<Type> *p = Find(t->leftChild,key);
        if(p != NULL)
            return p;
        return Find(t->rightChild,key);
    }
}
//右节点
BinTreeNode<Type>* RightChild(BinTreeNode<Type> *t,BinTreeNode<Type> *p)
{
    if(t==NULL || p==NULL)
        return NULL;
    else
        return p->rightChild;
}
//左节点
BinTreeNode<Type>* LeftChild(BinTreeNode<Type> *t,BinTreeNode<Type> *p)
{
    if(t==NULL || p==NULL)
        return NULL;
    else
        return p->leftChild;
}
bool IsEmpty(BinTreeNode<Type> *t)
{
    return t==NULL?true:false;
}
BinTreeNode<Type>* Root(BinTreeNode<Type> *t)
{
    //return t;
    if(t == NULL)
        return NULL;
    else
        return t;
}
//层次遍历二叉树 -- 队列创建
void LevelOrder(BinTreeNode<Type> *t)const
{
    if(t == NULL)
        return;
    else
    {
        queue<BinTreeNode<Type>* > Q;
        BinTreeNode<Type> *p = t;
        Q.push(p);
        while(!Q.empty())
        {
            cout<<p->data;
            if(p->leftChild != NULL)
                Q.push(p->leftChild);
            if(p->rightChild != NULL)
                Q.push(p->rightChild);
            Q.pop();
            if(!Q.empty())
            {p = Q.front(); }
        }
    }
}
//先序遍历
void PreOrder(BinTreeNode<Type> *t)const
{
    if(t != NULL)
    {
        cout<<t->data;
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
//中序遍历
void InOrder(BinTreeNode<Type> *t)const
{
    if(t != NULL)
    {           
        InOrder(t->leftChild);
        cout<<t->data;
        InOrder(t->rightChild);
    }

}
//后序遍历
void PostOrder(BinTreeNode<Type> *t)const
{
    if(t != NULL)
    {           
        PostOrder(t->leftChild);
        PostOrder(t->rightChild);
        cout<<t->data;
    }
}
//非递归前序遍历二叉树
void NPreOrder(BinTreeNode<Type> *t)const  //非递归 stack
{
    if(t == NULL)
        return;
    stack<BinTreeNode<Type>*> S;
    BinTreeNode<Type> *p = t;

    while(!S.empty() || p)
    {   
        if(p != NULL)
        {   
            S.push(p); //入栈
            cout<<p->data; //访问根节点
            p = p->leftChild; //访问左节点
        }
        else
        {
            p = S.top();
            S.pop();
            p = p->rightChild;
        }
    }
}
//非递归 中序遍历二叉树
void NInOrder(BinTreeNode<Type> *t)const
{
    if(t == NULL)
        return;
    stack<BinTreeNode<Type>*> S;
    BinTreeNode<Type> *p = t;
    while(!S.empty() || p)
    {
        if(p != NULL)
        {
            S.push(p);
            p = p->leftChild;
        }
        else
        {
            p = S.top();
            cout<<p->data;
            S.pop();
            p = p->rightChild;
        }   
    }
}
//非递归后序遍历二叉树
void NPostOrder(BinTreeNode<Type> *t)const
{

    stack<BinTreeNode<Type> *> S;
    BinTreeNode<Type> *p=t;  //当前节点
    BinTreeNode<Type> *pre=NULL; //指向前一个被访问的节点

    while(p || !S.empty()) 
    {
        while(p != NULL) //一直走到左子树为空时
        {
            S.push(p);
            p=p->leftChild; 
        }
        //当前节点的右子树为空或者已被访问，则访问当前节点
        p=S.top();
        if(p->rightChild==NULL || p->rightChild == pre)
        {
        //  p=S.top();
            cout<<p->data;
            pre = p;
            S.pop();
            p=NULL;
        }
        else  //否则访问右子树
            p=p->rightChild;        
    }       
}
private:
  //先序创建二叉树
    BinTreeNode<Type>* CreateBinTree1(char *&str)
    {
        if(*str == StopFlag)
            return NULL;
        else
        {
            BinTreeNode<Type> *t = new BinTreeNode<Type>(*str);
            t->leftChild = CreateBinTree1(++str);
            t->rightChild = CreateBinTree1(++str);
            return t;
        }

}
void CreateBinTree(BinTreeNode<Type> *&t, const char *&str)
{
    if(*str == StopFlag)
        t = NULL;
    else
    {
        t = new BinTreeNode<Type>(*str);
        CreateBinTree(t->leftChild,++str);
        CreateBinTree(t->rightChild,++str);
    }
}
void CreateBinTree(BinTreeNode<Type> *&t)
{
    Type item;
    cin>>item;
    if(item == StopFlag)
        t = NULL;
    else
    {
        t = new BinTreeNode<Type>(item);
        CreateBinTree(t->leftChild);
        CreateBinTree(t->rightChild);
    }
}
//ABC##DE##F##G#H##

//ABCDEFGH –前序 
//CBEDFAGH –中序 
//CEFDBHGA – 后序

//主函数功能的实现
    void main()
    {
        char *str = "ABC##DE##F##G#H##";
        char *VLR = "ABCDEFGH";
        char *LVR = "CBEDFAGH";
        char *LRV = "CEFDBHGA";
        BinTree<char> mytree('#');
        mytree.CreateBinTree();
        //mytree.CreateBinTree(str);
            mytree.CreateBinTree(str);
        cout<<mytree.Height()<<endl;
        mytree.PreOrder();
        cout<<endl;
        mytree.InOrder();
        cout<<endl;
        mytree.PostOrder();
        cout<<endl;
        mytree.CreateBinTreeByPreMid(VLR,LVR,8);
        mytree.CreateBinTreeByMidPost(LVR,LRV,8);
    }

二叉树的实现C++实现
sinat_40408114的博客
08-04 785
树的基本性质 定义： 1.一棵树t是一个非空的有限元素的集合，其中一个元素为根(root)，其余的元素(如果有的话)组成t的子树(subtree)。 2.一棵树的高度(height)或深度(depth)是树中级的个数。 3.一个元素的度(degree of an element)是指其孩子的个数，叶节点的度为0。一棵树的度(degree of a tree)是指其元素的度的最大值。 二叉树 定义...
C++实现二叉树
qq_45285738的博客
03-10 1566
接下来，你将看到，输出先序、层序遍历结果等内容，如下：（注：中序后序，操作类似于前序遍历，没有实现）1.2 实现二叉树的访问 --- 先中后序访问、层序访问。1.3 计算树的深度、节点数、复制树。2.1 首先创建出一棵二叉树。1.1 实现二叉树的创建。
C++之二叉搜索树
最新发布
2302_81120572的博客
03-25 730
C++之二叉搜索树
C++二叉树的实现
ranjiewen的博客
09-20 606
C++实现二叉查找树 啥是二叉查找树 在数据结构中，有一个奇葩的东西，说它奇葩，那是因为它重要，这就是树。而在树中，二叉树又是当中的贵族。二叉树的一个重要应用是它们在查找中的应用，于是就有了二叉查找树。 使二叉树成为一颗二叉查找树，需要满足以下两点： 对于树中的每个节点X，它的左子树中所有项的值都要小于X中的项； 对于树中的每个节点Y，它的右子树中所有项的值都要大于Y中的项。
二叉树 C++实现
YnnuSL的博客
04-19 331
二叉树 C++实现 支持插入、删除、查找操作 实现二叉树的前、中、后序遍历（包括递归和非递归） #include <climits> #include <iostream> #include <stack> #ifndef BINARY_SEARCH_TREE #define BINARY_SEARCH_TREE const int INF = INT_M...
二叉树C++实现
10-27
二叉树 C++ 实现通 过C++类来实现的
二叉树c++实现
11-11
二叉树简单功能实现包括查找插入删除等更功能
C++二叉树的实现 C++二叉树的实现
03-15
C++ 二叉树 C++ 二叉树 C++ 二叉树 C++ 二叉树
二叉树最简单实现（c++）
08-09
NULL 博文链接：https://448230305.iteye.com/blog/2193726
C++语言 二叉树实现
qq_39998031的博客
03-24 458
`#include using namespace std; #define BinNodePosi(T) BinNode* //节点位置 //BinNode模板类的设计 template struct BinNode { BinNodePosi(T) parent, lc, rc; T data; int lenght; int size(); BinNodePosi(T) insertAsL...
二叉树链表C++实现
Jinyao的博客
08-09 911
二叉树链表C++实现 结点的构造 源代码：https://github.com/cjy513203427/C_Program_Base/tree/master/57.%E4%BA%8C%E5%8F%89%E6%A0%91%E9%93%BE%E8%A1%A8%E5%AE%9E%E7%8E%B0 #pragma once #ifndef ...
二叉树(C++实现)
liushaozhuanyong的博客
09-28 478
二叉树实现 功能：1.遍历二叉树 2.检测二叉树是否为空 3.构建、删除树结点  4.先序（根、左、右）， 中序（左、根、右），后序（左、右、根） 《数据结构》南京邮电大学学习期间2016.9.28 /*对于遍历运算， 设计了一个面向用户的公有成员函数 和一个具体实现遍历操作的递归私有成员函数， 两者共同 完成遍历运算的功能。 */ #pragma once #include
二叉树的实现（c++）
qq_43667986的博客
11-14 838
二叉树的实现（c++） BinNode.h（节点的实现实现） template &amp;lt;typename E&amp;gt; class BinNode { public: virtual ~BinNode() {}; virtual E&amp;amp; element() = 0; virtual void setElement(const E&amp;amp;) = 0; virtual BinNode* ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值