二叉树相关操作

最新推荐文章于 2022-09-12 17:58:40 发布
最新推荐文章于 2022-09-12 17:58:40 发布
阅读量321 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDNMARKT/article/details/78744860
版权
    //1.定义、封装二叉树（构造、遍历（递归、非递归））
    //2.部分树的操作 
//1.定义、封装二叉树（构造、遍历（递归、非递归））
    //2.部分树的操作
    
#include <iostream>
#include<queue>
#include<stack>
#include<string>
using namespace std;
typedef char intT;
class node                                      //树结点类
{
private:
    intT elem;
    node *lchild;
    node *rchild;
public:
    friend class binarytree;
    node()                                           //构造函数1
    {
        elem=0;
        lchild=rchild=NULL;
    }
    node(const intT& t)                             //构造函数2
    {
        elem=t;
        lchild=rchild=NULL;
    }
    node(const intT& t,node* l,node* r)               //构造函数3
    {
        elem=t;
        lchild=l;
        rchild=r;
    }
    node* get_left_child()
    {
        return lchild;
    }
    node* get_right_child()
    {
        return rchild;
    }
    void set_left_child(node* l)
    {
        lchild=l;
    }
    void set_right_child(node* r)
    {
        rchild=r;
    }
    intT get_value()
    {
        return elem;
    }
    void set_value(const intT& t)
    {
        elem=t;
    }
    bool isleaf()
    {
        if(lchild==NULL&&rchild==NULL)      return true;
        else        return false;
    }
    node * pi_construct_binarytree(string pre_str,string in_str)    //前序中序构造二叉树
    {
        char root_value=pre_str[0];
        node * rot=new node;
        rot->elem=root_value;
        rot->lchild=rot->rchild=NULL;
        int llen=in_str.find(root_value),rlen=in_str.length()-llen-1;
        if(llen==0)     rot->lchild=NULL;
        else if(llen>0)
        {
            rot->lchild=pi_construct_binarytree(pre_str.substr(1,llen),in_str.substr(0,llen));
        }
        else    return NULL;
        if(rlen==0)         rot->rchild=NULL;
        else if(rlen>0)
        {
            rot->rchild=pi_construct_binarytree(pre_str.substr(llen+1,rlen),in_str.substr(llen+1,rlen));
        }
        else     return NULL;
    }
    node * ip_construct_binarytree(string in_str,string post_str)   //中序后序构造二叉树
    {
        char root_value=post_str[post_str.length()-1];
        node *rot=new node;
        rot->elem=root_value;
        rot->lchild=rot->rchild=NULL;
        int llen=in_str.find(root_value),rlen=in_str.length()-llen-1;
        if(llen==0)     rot->lchild=NULL;
        else if(llen>0)
        {
            rot->lchild=ip_construct_binarytree(in_str.substr(0,llen),post_str.substr(0,llen));
        }
        else    return NULL;
        if(rlen==0)         rot->rchild=NULL;
        else if(rlen>0)
        {
            rot->rchild=ip_construct_binarytree(in_str.substr(llen+1,rlen),post_str.substr(llen,rlen));
        }
        else     return NULL;
    }
    void exchange_node(node *p)                 //交换左右结点
    {
        node *temp=p->lchild;
        p->lchild=p->rchild;
        p->rchild=temp;
    }

};
void visit(node* p);
class binarytree                                //树类
{
private:
    node * root;
public:
    binarytree(node* p)
    {
        root=p;
    }
    ~binarytree()
    {
        delete root;
    }
    bool isempty()
    {
        if(root)    return false;
        else    return true;
    }
    int Total()                                             //统计结点个数
    {
        int total=0;
        node *p=root;
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)           total++;
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
        return total;
    }
    node* get_root()
    {
        return root;
    }
    node* get_father(node* cnode)                               //返回cnode的父结点
    {
        queue<node*> que;
        node* p=root;
        if(p)   que.push(p);
        while(!que.empty())
        {
            p=que.front();
            if(p->lchild==cnode||p->rchild==cnode)      return p;
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
    }
    node* get_left_brother(node* cnode)
    {
        queue<node*> que;
        node* p=root;
        if(p)   que.push(p);
        while(!que.empty())
        {
            p=que.front();
            if(p->lchild!=NULL&&p->rchild==cnode)      return p->lchild;
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
    }
    node* get_right_brother(node* cnode)
    {
        queue<node*> que;
        node* p=root;
        if(p)   que.push(p);
        while(!que.empty())
        {
            p=que.front();
            if(p->rchild!=NULL&&p->lchild==cnode)      return p->rchild;
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
    }
    node* get_left_child()
    {
        return root->lchild;
    }
    node* get_right_child()
    {
        return root->rchild;
    }
    queue<node*> breadth_find()                         //广度遍历，返回队列
    {
        queue<node*> que,qnode;
        node* p=root;
        if(p)   que.push(p);
        while(!que.empty())
        {
            p=que.front();
            visit(p);
            qnode.push(p);
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
        return qnode;
    }
    void pre_find(node* p)                           //前序遍历
    {
        //递归实现：
//        if(p)
//        {
//            visit(p);
//            pre_find(p->lchild);
//            pre_find(p->rchild);
//        }
        //非递归实现：
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)           visit(p);
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
    }
    void in_find(node* pnode)                        //中序遍历
    {
//        //递归实现：
//        if(p)
//        {
//            in_find(p->lchild);
//            visit(p);
//            in_find(p->rchild);
//        }
//        //非递归实现：
        stack<node*> s;
        node *p=pnode;
        while(!s.empty()||p)
        {
            if(p)
            {
             s.push(p);
             p=p->lchild;
            }
            else
            {
                p=s.top();
                visit(p);
                p=p->rchild;
                s.pop();
            }
        }
    }
    void post_find(node* rot)                        //后序遍历
    {
        //递归实现：
//        if(p)
//        {
//            post_find(p->lchild);
//            post_find(p->rchild);
//            visit(p);
//        }
        //非递归实现:
        stack<node*> s;
        node *p=rot;
        node *pre=rot;
        while(p)
        {
            for(;p->lchild!=NULL;p=p->lchild)
                s.push(p);
            while(p&&(p->rchild==NULL||p->rchild==pre))
            {
                visit(p);
                pre=p;
                if(s.empty())       return;
                p=s.top();
                s.pop();
            }
            s.push(p);
            p=p->rchild;
        }
    }
    void level_find()                               //广度遍历
    {
        queue<node*> que,qnode;
        node* p=root;
        if(p)   que.push(p);
        while(!que.empty())
        {
            p=que.front();
            visit(p);
            qnode.push(p);
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
    }
    void delete_node()
    {

    }
    int num_0()                    //返回度为0的结点个数
    {
        node *p=root;
        int total=0;
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)
            {
                if(p->isleaf())     total++;
            }
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
        return total;
    }
    int num_1()                    //返回度为1的结点个数
    {
        node *p=root;
        int total=0;
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)
            {
                if((p->lchild&&!p->rchild)||(p->rchild&&!p->lchild))     total++;
            }
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
        return total;
    }
    int num_2()                    //返回度为2的结点个数
    {
        node *p=root;
        int total=0;
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)
            {
                if(p->lchild&&p->rchild)     total++;
            }
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
        return total;
    }
    int countheight(node *p)        //返回高度
    {
        int height=0;
        if(p)
        {
            int lheight=countheight(p->lchild);
            int rheight=countheight(p->rchild);
            height=lheight>rheight?lheight+1:rheight+1;
        }
        return height;
    }
    int countweight()               //返回广度（每层结点的最大值）
    {
        queue<node*> que;
        node *p=root,*level=new node('1');
        int height=countheight(root),num[height],i=0,weight=0;
        for(int i=0;i<height;i++)
        {
            num[i]=0;
        }
        if(p)
        {
            que.push(p);
            que.push(level);
        }
        while(!que.empty())
        {
            p=que.front();
            if(p->elem=='1')
            {
                i++;
                que.pop();
                if(!que.empty())    que.push(p);
                continue;
            }
            else    num[i]++;
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
        delete level;
        for(int i=0;i<height;i++)
        {
            if(num[i]>=weight)      weight=num[i];
        }
        return weight;
    }
    intT maxvalue()                 //返回最大值
    {
        node *p=root;
        intT m='\0';
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)           m=p->elem>m?p->elem:m;
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
        return m;
    }
    void exchange_all_child()                            //交换所有结点的左右结点
    {
        node *p=root;
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)
            {
                p->exchange_node(p);
            }
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
    }
    void deleteleaf()
    {
        node *p=root;
        stack<node*> s;
        if(p)   s.push(p);
        while(!s.empty())
        {
            node* p=s.top();
            s.pop();
            if(p)
            {
                if(p->lchild)
                if(p->lchild->isleaf())
                {
                    delete p->lchild;
                    p->lchild=NULL;
                }
                if(p->rchild)
                if(p->rchild->isleaf())
                {
                    delete p->rchild;
                    p->rchild=NULL;
                }
            }
            if(p->rchild)   s.push(p->rchild);
            if(p->lchild)   s.push(p->lchild);
        }
    }
    node * get_last_node()                            //返回最后一个结点（按广度遍历）
    {
        node *p=root;
        if(p->isleaf())     return  p;
        else
        {
            while(p->lchild||p->rchild)
            {
                if(!p->lchild&&p->rchild)           p=p->rchild;
                else if(p->lchild&&!p->rchild)      p=p->lchild;
                else if(p->lchild&&p->rchild)      p=p->rchild;
            }
            return p;
        }
    }
    bool is_complete_bt()                            //判断是否为完全二叉树
    {
        queue<node*> que;
        node* p=root;
        if(p)   que.push(p);
        while(!que.empty())
        {
            p=que.front();
            if(p!=get_last_node())
            {
                if(p->isleaf())
                {
                    que.pop();
                    continue;
                }
                if(!p->lchild||!p->rchild)      return  false;
            }
            else    return true;
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
    }
};
void visit(node* p)
{
    cout<<p->get_value()<<"  ";
}
void binarytree_create(node* p)                             //普通粗暴的二叉树初始化，见P93 图3-13
{
    node* n1=new node;      n1->set_value('b');     p->set_left_child(n1);
    node* n2=new node;      n2->set_value('c');     p->set_right_child(n2);
    node* n3=new node;      n3->set_value('d');     n1->set_right_child(n3);
    node* n4=new node;      n4->set_value('e');     n2->set_right_child(n4);
    node* n5=new node;      n5->set_value('f');     n3->set_left_child(n5);
    node* n6=new node;      n6->set_value('g');     n3->set_right_child(n6);
    node* n7=new node;      n7->set_value('h');     n4->set_right_child(n7);
}
int main()
{
    cout<<"前序为：abdfgceh  中序为：bfdgaceh  构造二叉树："<<endl;
    node *p=new node;
    p=p->pi_construct_binarytree("abdfgceh","bfdgaceh");
    binarytree bt1(p);
    cout<<"广度遍历:"<<endl;
    bt1.breadth_find();
    cout<<endl;
    cout<<"前序遍历:"<<endl;
    bt1.pre_find(bt1.get_root());
    cout<<endl;
    cout<<"中序遍历:"<<endl;
    bt1.in_find(bt1.get_root());
    cout<<endl;
    cout<<"后序遍历:"<<endl;
    bt1.post_find(bt1.get_root());
    cout<<endl;
    cout<<"后序为：fgdbheca  中序为：bfdgaceh  构造二叉树："<<endl;
    node *p1=new node;
    p1=p1->ip_construct_binarytree("BFDGACEH","FGDBHECA");
    binarytree bt(p1);
    cout<<"广度遍历:"<<endl;
    bt.breadth_find();
    cout<<endl;
    cout<<"前序遍历:"<<endl;
    bt.pre_find(bt.get_root());
    cout<<endl;
    cout<<"中序遍历:"<<endl;
    bt.in_find(bt.get_root());
    cout<<endl;
    cout<<"后序遍历:"<<endl;
    bt.post_find(bt.get_root());
    cout<<endl;
    cout<<"结点一共有： "<<bt.Total()<<endl;
    cout<<"度为0的结点有： "<<bt.num_0()<<endl;
    cout<<"度为1的结点有： "<<bt.num_1()<<endl;
    cout<<"度为2的结点有： "<<bt.num_2()<<endl;
    cout<<"  高度为： "<<bt.countheight(bt.get_root())<<endl;
    cout<<"  宽度为： "<<bt.countweight()<<endl;
    cout<<"结点最大值为： "<<bt.maxvalue()<<endl;
    cout<<"此树是否为完全二叉树：  "<<bt.is_complete_bt()<<endl;
    cout<<"交换左右结点后前序遍历： "<<endl;
    bt.exchange_all_child();
    bt.pre_find(bt.get_root());
    cout<<endl;
    cout<<"删除所有叶子结点后前序遍历： "<<endl;
    bt.deleteleaf();
    bt.pre_find(bt.get_root());
    cout<<endl;
    cout << "Hello world!" << endl;
    return 0;
}


//修改关于判断是否二叉树的代码：

node * get_last_node()                            //返回最后一个结点（按广度遍历）
    {
        node *p=root;
        if(p->isleaf())     return  p;
        else
        {
            queue<node*> que,qnode;
            if(p)   que.push(p);
            while(!que.empty())
            {
                p=que.front();
                qnode.push(p);
                que.pop();
                if(p->lchild)       que.push(p->lchild);
                if(p->rchild)       que.push(p->rchild);
            }
            return p;
        }
    }
    bool is_complete_bt()                            //判断是否为完全二叉树
    {
        queue<node*> que;
        node* p=root;
        int i=0;	                        //i用来判断后续是否全是叶子结点，如果遍历时发现一个结点是叶子结点，那么之后若不全为叶子结点则返回false
        if(p)   que.push(p);
        while(!que.empty())
        {
            p=que.front();
            if(p!=get_last_node())
            {
                if(p->isleaf())
                {
                    i=1;
                    que.pop();
                    continue;
                }
                else
                {
                    if(i==1)        return false;
                }
                if(!p->lchild||!p->rchild)      return  false;
            }
            que.pop();
            if(p->lchild)       que.push(p->lchild);
            if(p->rchild)       que.push(p->rchild);
        }
        return true;
    }
修改原因：未能正确返回广度遍历下的最后一个结点

二叉树的相关操作（上）
谢广涛的博客
04-29 338
本文章主要介绍二叉树的概念、特点、以及二叉树的相关操作。1.二叉树的概念一棵二叉树时节点的有限集合，该二叉树或者为空树、或者为只有一个根节点的树、或者为一个根节点有左右子树的树。总之，二叉树的每个节点最多有两个子树。下面画图表示二叉树的几种情况：2. 二叉树的特点（1）二叉树是递归定义的；（2）二叉树的每个节点最多有两个子树即二叉树的度均不大于2；（3）二叉树的子树有左右之分，其左右子树的次序不能...
二叉树的相关操作
weixin_42223701的博客
09-30 194
###二叉树 1、二叉树的建立 二叉树的结点添加，即为二叉树的建立 外部类为树，根节点，结点的个数 内部类（结点类，添加结点的方法（递归方法）） 左节点，右结点，父节点 package binarytree; public class BinaryTree { private Node root; private int count; public class Node{ private int data; private Node left;
二叉树 相关操作
outlier的博客
06-10 298
#include #include #include #define TREE_TYPE inttypedef struct tree_node {TREE_TYPE value;struct tree_node *left;struct tree_node *right;}TreeNode;/**指向根节点的指针，static 防止其他文件修改*///static TreeNode *tree;
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
二叉树相关操作java实现
04-22
1:构造一个二叉树 2:二叉树前序遍历(递归) 3:二叉树中序遍历(递归) 4:二叉树后续遍历(递归) 5:二叉树前序遍历(非递归) 6:二叉树中序遍历(非递归) 7:二叉树后序遍历(非递归)
二叉树相关操作代码
05-08
根据给定文件的信息，我们可以详细地探讨一下二叉树数据结构以及如何通过...以上就是对给定文件中所涉及的二叉树相关操作的详细解析。通过对这些操作的理解和实现，可以帮助我们更好地掌握二叉树这一重要的数据结构。
数据结构——二叉树有关操作程序
12-17
二)二叉树的一些基本操作 (1)返回二叉树的根； (2)返回树中某个结点的左孩子，若无则返回“空”； (3)返回树中某个结点的双亲，如果是根结点，则返回“空”； 三) 在（二）的基础上，求二叉树的深度+结点数 (1)求...
二叉树相关基本操作
weixin_52875110的博客
09-12 228
无论是前序中序还是后序的代码只有一处输出语句的不同，这个跟。前序（根左右）我们手动模拟的话结果是。先看一下前序遍历对这棵树。
二叉树的相关操作（下）
谢广涛的博客
05-08 262
本文章是关于二叉树的非递归实现先序遍历、中序遍历、后序遍历、层序遍历以及求二叉树的镜像、判定一棵二叉树是否为完全二叉树、利用先序遍历和中序遍历的结果还原二叉树的操作。
C++实现二叉树遍历操作
接着，定义了一个名为`BiTree`的类，其中包含一个根节点`root`和一系列与二叉树操作相关的成员函数。 1. **创建二叉树**: `BiTree`类的构造函数`BiTree()`调用了`creat()`私有方法来初始化根节点。`creat()`函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值