二叉树相关操作

最新推荐文章于 2024-03-20 15:17:15 发布
最新推荐文章于 2024-03-20 15:17:15 发布
阅读量315 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 二叉树
版权声明：本文为博主原创文章，遵循 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;
    }
修改原因：未能正确返回广度遍历下的最后一个结点

csdnMARKT
关注
专栏目录
link链表类实验（多文件模式）
keyboardnobug的博客
04-20 2564
实验讲义 一、实验目的 1．掌握使用new运算符创建对象的方法； 2．掌握使用delete运算符释放对象内存的方法； 3．掌握使用面向对象思想实现链表类并对链表进行操作的方法。 二、实验内容 1．设计并编写链表类，能够实现链表的初始化（建立）、输出释放等功能。 三、实验指导 （1）链表由若干个结点【Node类对象】构成（每个结点有data域和next域，假设每个结点的data域是一个整数，并且没有...
二叉树的构建
li123128的博客
11-10 3336
二叉树是一种非常重要的数据结构。本文总结了二叉树的常见操作：二叉树的构建，查找，删除，二叉树的遍历(包括前序遍历、中序遍历、后序遍历、层次遍历)，二叉搜索树的构造等。
二叉树的使用方法
qq_30534935的博客
02-11 1285
转载： http://blog.jobbole.com/108184/ https://blog.csdn.net/zhanggonglalala/article/details/79738213 https://blog.csdn.net/heyanxi0101/article/details/79593542 一、概述 平衡树：所有结点左右子树深度差≤1 排序树：所有结点“左小右大 字典树：由...
二叉树的相关操作（C语言版）
m0_74216612的博客
01-14 379
这可能是关于数据结构C语言版中对于二叉树的很全面的总结了，有需要可以点击来看看。
数据结构_二叉树(性质、相关操作及实现代码)
最新发布
2301_80653026的博客
03-20 1214
/定义一个节点//左节点//右节点} }
二叉树相关操作java实现
04-22
1:构造一个二叉树 2:二叉树前序遍历(递归) 3:二叉树中序遍历(递归) 4:二叉树后续遍历(递归) 5:二叉树前序遍历(非递归) 6:二叉树中序遍历(非递归) 7:二叉树后序遍历(非递归)
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
二叉树相关操作代码
05-08
根据给定文件的信息，我们可以详细地探讨一下二叉树数据结构以及如何通过...以上就是对给定文件中所涉及的二叉树相关操作的详细解析。通过对这些操作的理解和实现，可以帮助我们更好地掌握二叉树这一重要的数据结构。
二叉树_二叉树的基础操作_
09-30
二叉树是计算机科学中一种重要的数据结构，它在算法设计和数据组织中扮演着核心角色。本节我们将深入探讨二叉树的基础操作，包括节点的定义、树...通过不断实践和探索，你可以进一步提升在二叉树及相关领域的专业能力。
平衡二叉树操作的演示
07-02
(1)初始，平衡二叉树为空树，操作界面给出查找、插入和删除三种操作供选择。每种操作均要提示输入关键字。每次插入或删除一个结点后，应更新平衡二叉树的显示。 (2)平衡二叉树的显示可采用如6.69题要求的凹入表形式，也可以采用图形界面画出树形。(3)教科书已给出查找和插入算法，本题重点在于对删除算法的设计和实现。假设要删除关键字为x的结点。如果x不在叶子结点上，则用它左子树中的最大值或右子树中的最小值取代x。如此反复取代，直到删除动作传递到某个叶子结点。删除叶子结点时，若需要进行平衡变换，可采用插入的平衡变换的反变换(如，左子树变矮对应于右子树长高)。
二叉树的基本操作
hhhhh_555的博客
12-05 3281
文章目录二叉树结点与叶子 结点层数树的结构定义树的遍历方式先序遍历中序遍历后序遍历创建树先序创建树中序创建树后序创建树求树的基本参数树的高度树的结点数树的叶子结点树完整代码 /* *@author zhazhazhi *qq:2055418639 *github:zhazhazhi7 */ 二叉树 二叉树是数据结构不可或缺的结构，二叉树中又有完全二叉树与满二叉树。学会二叉树，就要先了解二叉树的结构。 结点与叶子 结点 二叉树的每一个数据叫做结点，其中最上方的结点叫做头结点，每个结点有两个分支，分别叫左孩子
二叉树的基本操作（共21个）
CXR_XC的博客
11-04 9546
简单介绍二叉树，并给出二叉树的21种基本操作
【数据结构】 二叉树相关操作（详解）
Suk_god的博客
12-25 2351
二叉树 堆操作 堆排序 Top-K问题 二叉树的创建
二叉树所有基本操作
weixin_55858644的博客
01-06 6640
最全的二叉树基本操作
实现二叉树的一些基本操作
m0_62556295的博客
10-20 955
二叉树
C++实现二叉树遍历操作
接着，定义了一个名为`BiTree`的类，其中包含一个根节点`root`和一系列与二叉树操作相关的成员函数。 1. **创建二叉树**: `BiTree`类的构造函数`BiTree()`调用了`creat()`私有方法来初始化根节点。`creat()`函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值