二叉树总结（c++）

最新推荐文章于 2022-10-27 19:10:21 发布
最新推荐文章于 2022-10-27 19:10:21 发布
阅读量880 收藏 1
点赞数
分类专栏： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hp_satan/article/details/9359153
版权

先写着备忘，以后再解释！

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstring>
#include <queue>
#include <list>
#include <cstdlib>

//#define LOCAL

using namespace std;
typedef char Elemtype;


//二叉树节点的定义
class BinaryTreeNode
{
public:
    BinaryTreeNode(Elemtype _data='#',BinaryTreeNode *_lchild=NULL,BinaryTreeNode *_rchild=NULL):data(_data),lchild(_lchild),rchild(_rchild){}
    void Set_data(Elemtype item)
    {
        data=item;
    }
    Elemtype Get_data()const
    {
        return data;
    }

    void Set_lchild(BinaryTreeNode *_lchild)
    {
        lchild=_lchild;
    }
    BinaryTreeNode *Get_lchild()const
    {
        return lchild;
    }

    void Set_rchild(BinaryTreeNode *_rchild)
    {
        rchild=_rchild;
    }
    BinaryTreeNode *Get_rchild()const
    {
        return rchild;
    }

private:
    Elemtype data;
    BinaryTreeNode *lchild,*rchild;
};

class BinaryTreeFun
{
public:
    BinaryTreeFun(BinaryTreeNode *t=NULL):root(t){}
    ~BinaryTreeFun(){delete root;}

    void Set_root(BinaryTreeNode *item)
    {
        root=item;
    }
    BinaryTreeNode *Get_root()const
    {
        return root;
    }

    //先序创建二叉树
    BinaryTreeNode *Createtree();
    //先序,中序,后序遍历二叉树
    void Preorder(BinaryTreeNode *t)const;
    void Inorder(BinaryTreeNode *t)const;
    void Postorder(BinaryTreeNode *t)const;
    //层次遍历
    void Leveltraversal(BinaryTreeNode *t)const;
    //求节点个数
    int GetNodeNum(BinaryTreeNode *t)const;
    //求树的深度
    int GetDepth(BinaryTreeNode *t)const;
    //求叶子节点个数
    int GetLeafNum(BinaryTreeNode *t)const;
    //求第k层节点的个数
    int GetKNum(BinaryTreeNode *t,int k)const;
    //求二叉树的镜像
    void Mirror(BinaryTreeNode *t);
    //根据先序，中序遍历重建二叉树
    BinaryTreeNode *Pre_RebuildTree(char pre[],char in[],int pre_s,int pre_e,int in_s,int in_e);
    //根据后序，中序遍历重建二叉树
    BinaryTreeNode *Pos_RebuildTree(char pos[],char in[],int pos_s,int pos_e,int in_s,int in_e);
    //寻找位置
    int Find(char in[],char ch,int in_s,int in_e);
    //判断一个节点是否在树种
    bool Is_Tree_Node(BinaryTreeNode *r,BinaryTreeNode *nt)const;

    //求两个节点的最近公共祖先(递归求解)
    BinaryTreeNode *Get_Comment_Parent(BinaryTreeNode *r,BinaryTreeNode *p1,BinaryTreeNode *p2);
    //求两个节点的最近公共祖先(非递归求解)
    BinaryTreeNode *GetCommentParent(BinaryTreeNode *r,BinaryTreeNode *p1,BinaryTreeNode *p2);
    //求根节点到某一节点的路径
    bool GetNodePath(BinaryTreeNode *r,BinaryTreeNode *nt,list<BinaryTreeNode*>&p);
    //判断二叉树是不是完全二叉树
    bool Is_CompleteBinaryTree(BinaryTreeNode *r)const;
    //判断二叉树是否为平衡二叉树
    bool Is_AVL(BinaryTreeNode *t,int &height)const;
    //求二叉树节点间的最大距离
    int MostDistance(BinaryTreeNode *r,int &ldis,int &rdis);

private:
    BinaryTreeNode *root;
};

//函数实现
BinaryTreeNode* BinaryTreeFun::Createtree()
{
    char item;
    BinaryTreeNode *t,*tl,*tr;
    cin>>item;
    if(item!='#')
    {
        BinaryTreeNode *temp=new BinaryTreeNode(item);
        t = temp;
        tl = Createtree();
        t->Set_lchild(tl);
        tr=Createtree();
        t->Set_rchild(tr);
        return t;
    }
    else
    {
        t=NULL;
        return t;
    }
}

void BinaryTreeFun::Preorder(BinaryTreeNode *t)const
{
    if(t!=NULL)
    {
        cout<<t->Get_data()<<" ";
        Preorder(t->Get_lchild());
        Preorder(t->Get_rchild());
    }
}
void BinaryTreeFun::Inorder(BinaryTreeNode *t)const
{
    if(t!=NULL)
    {
        Inorder(t->Get_lchild());
        cout<<t->Get_data()<<" ";
        Inorder(t->Get_rchild());
    }
}
void BinaryTreeFun::Postorder(BinaryTreeNode *t)const
{
    if(t!=NULL)
    {
        Postorder(t->Get_lchild());
        Postorder(t->Get_rchild());
        cout<<t->Get_data()<<" ";
    }
}

void BinaryTreeFun::Leveltraversal(BinaryTreeNode *t)const
{
    if(t==NULL) return;
    queue<BinaryTreeNode*>que;
    que.push(t);
    while(!que.empty())
    {
        BinaryTreeNode *temp=que.front();
        que.pop();
        cout<<temp->Get_data()<<" ";
        if(temp->Get_lchild()!=NULL)
            que.push(temp->Get_lchild());
        if(temp->Get_rchild()!=NULL)
            que.push(temp->Get_rchild());
    }
}

int BinaryTreeFun::GetNodeNum(BinaryTreeNode *t)const
{
    if(t==NULL)
        return 0;
    int lnum=GetNodeNum(t->Get_lchild());
    int rnum=GetNodeNum(t->Get_rchild());
    return lnum+rnum+1;
}

int BinaryTreeFun::GetDepth(BinaryTreeNode *t)const
{
    if(t==NULL)
        return 0;
    int lnum=GetDepth(t->Get_lchild());
    int rnum=GetDepth(t->Get_rchild());
    return (lnum>rnum)?(lnum+1):(rnum+1);
}

int BinaryTreeFun::GetLeafNum(BinaryTreeNode *t)const
{
    if(t==NULL)
        return 0;
    if(t->Get_lchild()==NULL && t->Get_rchild()==NULL)
        return 1;
    int lnum=GetLeafNum(t->Get_lchild());
    int rnum=GetLeafNum(t->Get_rchild());
    return lnum+rnum;
}

int BinaryTreeFun::GetKNum(BinaryTreeNode *t,int k)const
{
    if(t==NULL || k<1)
        return 0;
    if(k==1)
        return 1;
    int lnum=GetKNum(t->Get_lchild(),k-1);
    int rnum=GetKNum(t->Get_rchild(),k-1);
    return lnum+rnum;
}

void BinaryTreeFun::Mirror(BinaryTreeNode *t)
{
    if(t==NULL)
        return ;
    BinaryTreeNode *temp=t->Get_lchild();
    t->Set_lchild(t->Get_rchild());
    t->Set_rchild(temp);

    Mirror(t->Get_lchild());
    Mirror(t->Get_rchild());
}

int BinaryTreeFun::Find(char in[],char ch,int in_s,int in_e)
{
    int i;
    for(i=in_s;i<=in_e;i++)
        if(in[i] == ch)
            return i;
}

BinaryTreeNode* BinaryTreeFun::Pre_RebuildTree(char pre[],char in[],int pre_s,int pre_e,int in_s,int in_e)
{
    if(in_s>in_e) return NULL;
    BinaryTreeNode *temp;
    temp=new BinaryTreeNode(pre[pre_s]);
    int mid=Find(in,pre[pre_s],in_s,in_e);
    temp->Set_lchild(Pre_RebuildTree(pre,in,pre_s+1,pre_s+mid-in_s,in_s,mid-1));
    temp->Set_rchild(Pre_RebuildTree(pre,in,pre_s+mid-in_s+1,pre_e,mid+1,in_e));
    return temp;
}

BinaryTreeNode* BinaryTreeFun::Pos_RebuildTree(char pos[],char in[],int pos_s,int pos_e,int in_s,int in_e)
{
    if(in_s>in_e) return NULL;
    BinaryTreeNode *temp;
    temp = new BinaryTreeNode(pos[pos_e]);
    int mid=Find(in,pos[pos_e],in_s,in_e);
    temp->Set_lchild(Pos_RebuildTree(pos,in,pos_s,pos_s+mid-in_s-1,in_s,mid-1));
    temp->Set_rchild(Pos_RebuildTree(pos,in,pos_s+mid-in_s,pos_e-1,mid+1,in_e));
    return temp;
}

bool BinaryTreeFun::Is_Tree_Node(BinaryTreeNode *r,BinaryTreeNode *nt)const
{
    if(r == NULL)
        return false;
    else if(r == nt)
        return true;
    else
    {
        bool temp=false;
        if(r->Get_lchild()!=NULL)
            temp=Is_Tree_Node(r->Get_lchild(),nt);
        if(!temp && r->Get_rchild()!=NULL)
            temp=Is_Tree_Node(r->Get_rchild(),nt);
        return temp;
    }
}

BinaryTreeNode* BinaryTreeFun::Get_Comment_Parent(BinaryTreeNode *r,BinaryTreeNode *p1,BinaryTreeNode *p2)
{
    if(Is_Tree_Node(r->Get_lchild(),p1))
    {
        if(Is_Tree_Node(r->Get_rchild(),p2))
            return r;
        else return Get_Comment_Parent(r->Get_lchild(),p1,p2);
    }
    else
    {
        if(Is_Tree_Node(r->Get_lchild(),p2))
            return r;
        else return Get_Comment_Parent(r->Get_rchild(),p1,p2);
    }
}


bool BinaryTreeFun::GetNodePath(BinaryTreeNode *r,BinaryTreeNode *nt,list<BinaryTreeNode*>&p)
{
    if(r == NULL)
        return false;
    if(r == nt)
    {
        p.push_back(r);
        return true;
    }
    p.push_back(r);
    bool temp=false;
    temp=GetNodePath(r->Get_lchild(),nt,p);
    if(!temp)
        temp=GetNodePath(r->Get_rchild(),nt,p);
    if(!temp)
        p.pop_back();
    return temp;
}

BinaryTreeNode* BinaryTreeFun::GetCommentParent(BinaryTreeNode *r,BinaryTreeNode *p1,BinaryTreeNode *p2)
{
    if(r == NULL || p1 == NULL || p2 == NULL)
        return NULL;
    list<BinaryTreeNode*>path1;
    bool res1=GetNodePath(r,p1,path1);
    list<BinaryTreeNode*>path2;
    bool res2=GetNodePath(r,p2,path2);

    if(!res1 || !res2)
        return NULL;

    BinaryTreeNode *pres=NULL;

    list<BinaryTreeNode*>::const_iterator ite1 = path1.begin();
    list<BinaryTreeNode*>::const_iterator ite2 = path2.begin();
    while(ite1!=path1.end() && ite2!=path2.end())
    {
        if(*ite1 == *ite2)
            pres=*ite1;
        else break;
        ite1++;
        ite2++;
    }
    return pres;
}

bool BinaryTreeFun::Is_CompleteBinaryTree(BinaryTreeNode *r)const
{
    if(r == NULL)
        return false;
    queue<BinaryTreeNode*>que;
    que.push(r);
    bool result(true);
    bool nullchild(false);
    while(!que.empty())
    {
        BinaryTreeNode *temp=que.front();
        que.pop();
        if(nullchild)
        {
            if(temp->Get_lchild()!=NULL || temp->Get_rchild()!=NULL)
                return false;
        }
        else
        {
            if(temp->Get_lchild()!=NULL && temp->Get_rchild()!=NULL)
            {
                que.push(temp->Get_lchild());
                que.push(temp->Get_rchild());
            }
            else if(temp->Get_lchild()!=NULL && temp->Get_rchild()==NULL)
            {
                que.push(temp->Get_lchild());
                nullchild=true;
            }
            else if(temp->Get_lchild()==NULL && temp->Get_rchild()!=NULL)
                return false;
            else nullchild=true;
        }
    }
    return result;
}

bool BinaryTreeFun::Is_AVL(BinaryTreeNode *r,int &height)const
{
    if(r == NULL)
    {
        height=0;
        return true;
    }
    int lh;
    bool lres=Is_AVL(r->Get_lchild(),lh);
    int rh;
    bool rres=Is_AVL(r->Get_rchild(),rh);
    if(lres && rres && abs(lh-rh)<=1)
    {
        height=max(lh,rh)+1;
        return true;
    }
    else
    {
        height=max(lh,rh)+1;
        return false;
    }
}


int BinaryTreeFun::MostDistance(BinaryTreeNode *r,int &ldis,int &rdis)
{
    if(r == NULL)
    {
        ldis=rdis=0;
        return 0;
    }
    int maxll,maxlr,maxrl,maxrr;
    int maxldis,maxrdis;
    if(r->Get_lchild()!=NULL)
    {
        maxldis=MostDistance(r->Get_lchild(),maxll,maxlr);
        ldis=max(maxll,maxlr)+1;
    }
    else
        maxldis=ldis=0;
    if(r->Get_rchild()!=NULL)
    {
        maxrdis=MostDistance(r->Get_rchild(),maxrl,maxrr);
        rdis=max(maxrl,maxrr)+1;
    }
    else
        maxrdis=rdis=0;
    return max(max(maxldis,maxrdis),ldis+rdis);
}

int main()
{
#ifdef LOCAL
    freopen("in.txt","r",stdin);
#endif // LOCAL


    BinaryTreeFun t;

    cout<<"请输入二叉树的前序序列，“#”表示节点为空:"<<endl;
    BinaryTreeNode *tt=t.Createtree();
    t.Set_root(tt);
    cout<<endl<<endl;

    int l,r;
    int dis=t.MostDistance(tt,l,r);
    cout<<"最大距离为:"<<dis<<endl<<endl;

    BinaryTreeNode *p1=t.Get_root()->Get_rchild()->Get_lchild();
    BinaryTreeNode *p2=t.Get_root()->Get_rchild()->Get_rchild();

    BinaryTreeNode *temp=t.GetCommentParent(t.Get_root(),p1,p2);

    cout<<p1->Get_data()<<"和"<<p2->Get_data()<<"的最近公共祖先是："<<temp->Get_data()<<endl<<endl;

    int h;
    bool ch=t.Is_AVL(tt,h);
    if(ch) cout<<"该二叉树是平衡二叉树"<<endl<<endl;
    else cout<<"该二叉树不是平衡二叉树"<<endl<<endl;
    cout<<"深度为："<<h<<endl<<endl;

    cout<<"前序遍历的结果：";
    t.Preorder(tt);
    cout<<endl<<endl;

    cout<<"中序遍历的结果：";
    t.Inorder(tt);
    cout<<endl<<endl;

    cout<<"后序遍历的结果：";
    t.Postorder(tt);
    cout<<endl<<endl;

    cout<<"层次遍历的结果：";
    t.Leveltraversal(tt);
    cout<<endl<<endl;

    cout<<"节点个数为：";
    int num1=t.GetNodeNum(tt);
    cout<<num1<<endl<<endl;

    cout<<"树的深度为：";
    int num2=t.GetDepth(tt);
    cout<<num2<<endl<<endl;

    cout<<"叶子节点个数为：";
    int num3=t.GetLeafNum(tt);
    cout<<num3<<endl<<endl;

    cout<<"输入您要查询的层数：    ";
    int k;
    cin>>k;
    cout<<endl<<"第"<<k<<"层节点个数为：";
    int num4=t.GetKNum(tt,k);
    cout<<num4<<endl<<endl;

    cout<<"二叉树的镜像先序遍历：";
    t.Mirror(tt);
    t.Preorder(tt);
    cout<<endl<<endl;
    cout<<"二叉树的镜像中序遍历：";
    t.Inorder(tt);
    cout<<endl<<endl;
    cout<<"二叉树的镜像后序遍历：";
    t.Postorder(tt);
    cout<<endl<<endl;


    char pos[100],in[100];
    cout<<"输入所要创建的二叉树的后序遍历序列：";
    scanf("%s",pos);
    cout<<"输入所要创建的二叉树的中序遍历序列：";
    scanf("%s",in);
    int len=strlen(pos);
    BinaryTreeNode *tttt=t.Pos_RebuildTree(pos,in,0,len-1,0,len-1);
    cout<<"重建二叉树的前序遍历：";
    t.Preorder(tttt);
    cout<<endl<<endl;


    return 0;
}


--子非鱼--
关注
专栏目录
C++二叉树总结（包含源码）一
sudo_feng的博客
03-08 161
#include<iostream> #include<string> #include<list> #include<cmath> #include<hash_map> using namespace std; class Node{ public: Node(int data){ t...
c++ || 详解二叉树
LQEmptycity的博客
08-17 1247
树
二叉树面试题 树和二叉树总结.doc
02-24
二叉树面试题 树和二叉树考研试题总结
C++二叉树遍历总结\100. Same Tree
I AM BACK
02-15 529
理论学习 概念介绍 遍历图解 遍历算法 代码实践 实现模板理论学习概念介绍二叉树的遍历分成前序、中序、后序遍历。前序就是访问结点的操作发生在遍历其左右子树之前。 中序就是访问结点的操作发生在遍历其左右子树之中，一般是遍历左边子树以后。 后序就是访问结点的操作发生在遍历其左右子树之后。这里可以参考【1】中，对数据结构做了一个整理。遍历图解 图中每个节点经过了3次。先序为： A B D C E F
C++ 统计二叉树所有结点数、叶子结点数
HarvestWu的博客
06-22 7831
 统计所有结点数：//统计所有结点数 int n1=0; void countAllNode(BTNode *p) { if(p!=NULL) { ++n1; countAllNode(p-&gt;lchild); countAllNode(p-&gt;rchild); } }统计叶子结点数：//统计叶子结点数 int n2=...
二叉树基础知识总结
zhf的博客
02-25 461
题外话昨晚面了腾讯，问了一个完全二叉树的题，竟然让我算了快10分钟，因为等比公式记错了导致最后用最原始的方法推算结果也没算对，一下子就懵了。本来精心准备了1周的面试，最后因为自己基础知识记忆不牢固导致了悲剧。不管怎样，还是要继续查漏补缺，准备将数据结构再细细看一遍，先来补上二叉树的这个漏洞吧。 一、...
重建二叉树[C++版]
爱着瓜瓜的花花的博客
09-14 561
重建二叉树[C++版]问题描述解决思想思想1：树的性质思想2：递归我的代码总结（附）Python实现代码 问题描述 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 例如，输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 解决思想 首先我们看一下C++版本的...
二叉树-基于C++实现的二叉树操作.zip
最新发布
04-26
总结来说，"二叉树-基于C++实现的二叉树操作.zip"这个压缩包文件很可能包含了以上讨论的二叉树概念、节点类定义、基本操作（插入、搜索、删除）以及遍历算法的C++代码实现。通过学习和理解这些内容，你可以掌握...
C++实现二叉树非递归遍历方法实例总结
01-20
一般来说，二叉树的遍历是C++程序员在面试中经常考察的，其实前中后三种顺序的遍历都大同小异，自己模拟两个栈用笔画画是不难写出代码的。现举一个非递归遍历的方法如下，供大家参考。 具体代码如下： class ...
平衡二叉树c++实现
09-26
总结，C++实现平衡二叉树，尤其是AVL树，需要深入理解二叉树的性质和旋转操作，同时，完善的测试代码是确保代码正确性和可靠性的关键。通过熟练掌握这些知识，可以有效地应用到实际的软件开发项目中，提升数据处理的...
C++实现二叉树基本操作详解
08-28
主要为大家详细介绍了C++实现二叉树基本操作，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C/C++二叉树
qq_61213622的博客
10-24 702
二叉树和堆
c++数据结构与算法之二叉树知识点总结
weixin_45376301的博客
02-05 230
c++数据结构与算法之二叉树二叉树关键点构造二叉树（使用链表来表示二叉树）链表节点链表构造二叉树遍历深度优先遍历前序遍历中序遍历后序遍历宽度优先遍历（层次遍历）复制二叉树前序遍历复制后序遍历复制二叉树层数与每一层的节点数目二叉树总的节点数目使用前序和中序遍历的结果恢复二叉树完整代码binaryTreeNode.h主文件 二叉树关键点 二叉树相关问题的解法主要就是两个 1.使用递归函数来进行深度优先搜索，比如二叉树的前序遍历、中序遍历、后序遍历以及通过二叉树的两个遍历顺序的结果来恢复出二叉树，这些都是通过递归
算法面试题-----二叉树完整刷题总结
爱喝舒化奶的博客
03-19 3386
题目：输入一颗二叉树，返回他的深度（包括最大深度，最小深度） 解题：可以通过DFS，BFS两种方式进行计算 【剑指offer】面试题55 二叉树的深度 leetcode 104. Maximum Depth of Binary Tree （求二叉树的最大深度,DFS,BFS） leetcode 111. Minimum Depth of Binary Tree(求二叉树的最小深度，DFS,BFS)...
数据结构(C++)——二叉树的基本操作——多种遍历，计算各种节点数，交换子树
m0_62038333的博客
10-27 675
一个具有操作菜单的二叉树基本操作。功能包括：1.通过先序法创建二叉树；2.然后实现先序、中序、后序和按层遍历二叉树；3.实现求二 叉树的总结点数、叶子节点树、单、双分支节点个数；4.实现求二 叉树的深度；.交换二叉树的左右子树等。
基于C++的二叉树的基本操作
CX299792458的博客
10-27 233
代码仅供参考（手动滑稽） #include <iostream> using namespace std; typedef struct BitNode{ char data; BitNode *lchild; BitNode *rchild; }BitNode; class bitt{ private: BitNode * bt; void create(BitNode *&t) ; int countleaf(BitNode
算法学习 - 线索二叉树
累了就歇一会
11-23 1534
线索二叉树 线索二叉树就是在通用的二叉树里多了点东西，多了什么呢？ 前驱和后继，把二叉树变成一个链式的结构。解释下：通常我们的二叉树里，叶子节点是没有孩子，所以指向空也就是NULL，在线索二叉树里，叶子节点的左右孩子分别指向它自己的前驱和后继，而前驱和后继是哪个节点呢？ 就是树遍历过程的前一个节点和后一个节点。所以第一个遍历的节点是没有前驱的，最后一个节点是没有后继的。这里一般都是中序线
[C++]二叉树总结
stary_yan的博客
05-08 2412
[C++]封装二叉树题目要求（简单的说，就是把二叉树的功能封装起来）binary tree is a tree data structure in which each node has at most two children, which are referred to as the left child and the right child.Three Constructor:creat a
一名在校大学生的二叉树入门知识
理想二旬不止 - 专注JAVA技术
11-10 545
image 二叉树铺垫——树 前面几篇文章我们主要介绍的线性表，栈，队列，串，等等，都是一对一的线性结构，而今天我们所讲解的 “树” 则是一种典型的非线性结构，非线性结构的特点就是，任意一个结点的直接前驱，如果存在，则一定是唯一的，直接后继如果存在，则可以有多个，也可以理解为一对多的关系，下面我们就先来认识一下树 树的概念 下图我们日常生活中所见到的树，可以看到，从主树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值