二叉树的基本操作--递归

最新推荐文章于 2022-04-14 21:07:58 发布
最新推荐文章于 2022-04-14 21:07:58 发布
阅读量259 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hm108106/article/details/71173611
版权

1.创建结构体保存二叉树的节点，每个节点有值，左孩子，右孩子

template<class T>
struct BinaryTreeNode
{
    T _value;
    BinaryTreeNode<T>* _pLeft;//左孩子
    BinaryTreeNode<T>* _pRight;//右孩子

    BinaryTreeNode(const T& value)
        :_value(value)
        ,_pLeft(NULL)
        ,_pRight(NULL)
    {}
};

2.构造函数及拷贝构造函数

    BinaryTree()
        :_pRoot(NULL)
    {}
    BinaryTree(const T array[],size_t size,const T& invalid)//构造函数
    {
        size_t index=0;
        _CreateBinaryTree(_pRoot,array,size,index,invalid);
    }
    BinaryTree(const BinaryTree<T>& bt)//拷贝构造函数
    {
        _pRoot=_CopyBinaryTree(bt._pRoot);
    }

3.析构函数

~BinaryTree()
    {
        _DestroyBinaryTree(_pRoot);
    }

4.创建二叉树的函数

void _CreateBinaryTree(Node* &pRoot,const T array[],size_t size,size_t& index,const T& invalid)
    {
        if(index<size&&invalid!=array[index])
        {
            pRoot=new Node(array[index]);
            _CreateBinaryTree(pRoot->_pLeft,array,size,++index,invalid);//创建左子树
            _CreateBinaryTree(pRoot->_pRight,array,size,++index,invalid);//创建右子树
        }
    }

5.拷贝函数

Node* _CopyBinaryTree(Node* pRoot)//拷贝
    {
        Node* pNewRoot=NULL;
        if(pRoot)
        {
            //拷贝根节点
            pNewRoot=new Node(pRoot->_value);
            //拷贝左子树
            pNewRoot->_pLeft=_CopyBinaryTree(pRoot->_pLeft);
            //拷贝右子树
            pNewRoot->_pRight=_CopyBinaryTree(pRoot->_pRight);
        }
        return pNewRoot;
    }

6.销毁函数

void _DestroyBinaryTree(Node* &pRoot)
    {
        if(pRoot)
        {
            _DestroyBinaryTree(pRoot->_pLeft);
            _DestroyBinaryTree(pRoot->_pRight);
            delete pRoot;
            pRoot=NULL;
        }
    }

7.二叉树的三种遍历

void _PreOrder(Node* pRoot)//前序遍历
    {
        if(pRoot)
        {
            cout<<pRoot->_value<<" ";
            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }
    void _InOrder(Node* pRoot)//中序遍历
    {
        if(pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout<<pRoot->_value<<" ";
            _InOrder(pRoot->_pRight);
        }
    }
    void _PostOrder(Node* pRoot)//后序遍历
    {
        if(pRoot)
        {   
            _PostOrder(pRoot->_pLeft);
            _PostOrder(pRoot->_pRight);
            cout<<pRoot->_value<<" ";
        }
    }

8.二叉树的基本操作

Node* _Find(Node* pRoot,const T& value)//根据值寻找二叉树中的相应结点
    {
        if(NULL==pRoot)
            return NULL;
        if(pRoot->_value==value)
            return pRoot;   
        Node* pCur=NULL;
        if(pCur=_Find(pRoot->_pLeft,value))
            return pCur;
        return _Find(pRoot->_pRight,value);

    }
    Node* _Parent(Node* pRoot,Node* pCur)//获取双亲,pRoot为根节点 
    {
        assert(pCur);
        if(pRoot==NULL||pCur==pRoot)
            return NULL;
        if((pCur==pRoot->_pLeft)||(pCur==pRoot->_pRight))
            return pRoot;
        Node* ret=NULL;
        if(ret=_Parent(pRoot->_pLeft,pCur))
            return ret;
        else
            return _Parent(pRoot->_pRight,pCur);
    }
    Node* _LeftChild(Node* pRoot,Node* pCur)//寻找左孩子
    {
        assert(pCur);
        if(pRoot!=NULL && pCur->_pLeft!=NULL)
            return pCur->_pLeft;
        Node* ret=NULL;
        if(ret=_LeftChild(pRoot->_pLeft,pCur))
            return ret;
        else
            return _LeftChild(pRoot->_pRight,pCur);

    }
    Node* _RightChild(Node* pRoot,Node* pCur)//寻找右孩子
    {
        assert(pCur);
        if(pRoot!=NULL && pCur->_pRight!=NULL)
            return pCur->_pRight;
        Node* ret=NULL;
        if(ret=_RightChild(pRoot->_pLeft,pCur))
            return ret;
        else
            return _RightChild(pRoot->_pRight,pCur);

    }
    size_t _Height(Node* pRoot)//计算二叉树的深度
    {
        int hl=0;
        int hr=0;
        int max=0;
        if(pRoot!=NULL)
        {
            hl=_Height(pRoot->_pLeft);
            hr=_Height(pRoot->_pRight);
            max=hl>hr?hl:hr;
            return max+1;
        }
        else
            return 0;
    }
    size_t _GetLeefCount(Node* pRoot)//计算叶子结点的个数
    {
        if(pRoot==NULL)
            return 0;
        if(NULL==pRoot->_pLeft && NULL==pRoot->_pRight)
            return 1;
        return _GetLeefCount(pRoot->_pLeft)+_GetLeefCount(pRoot->_pRight);
    }
    size_t _GetKLevelCount(Node* pRoot,size_t k)//计算K行的节点个数
    {
        if(pRoot==NULL||k<1)
            return 0;
        if(k==1)
            return 1;
        return _GetKLevelCount(pRoot->_pLeft,k-1)+_GetKLevelCount(pRoot->_pRight,k-1);
    }
    void _BinaryMirror(Node* pRoot)//镜像树
    {
        if(pRoot)
        {
            std::swap(pRoot->_pLeft,pRoot->_pRight);
            _BinaryMirror(pRoot->_pLeft);
            _BinaryMirror(pRoot->_pRight);
        }
    }

完整代码：

#include<iostream>
#include<queue>
#include<assert.h>
using namespace std;

template<class T>
struct BinaryTreeNode
{
    T _value;
    BinaryTreeNode<T>* _pLeft;//左孩子
    BinaryTreeNode<T>* _pRight;//右孩子

    BinaryTreeNode(const T& value)
        :_value(value)
        ,_pLeft(NULL)
        ,_pRight(NULL)
    {}
};

template<class T>
class BinaryTree
{
public:
    typedef BinaryTreeNode<T> Node;
    BinaryTree()
        :_pRoot(NULL)
    {}
    BinaryTree(const T array[],size_t size,const T& invalid)//构造函数
    {
        size_t index=0;
        _CreateBinaryTree(_pRoot,array,size,index,invalid);
    }
    BinaryTree(const BinaryTree<T>& bt)//拷贝构造函数
    {
        _pRoot=_CopyBinaryTree(bt._pRoot);
    }
    ~BinaryTree()
    {
        _DestroyBinaryTree(_pRoot);
    }
    BinaryTree<T>& operator=(const BinaryTree<T>& bt)
    {
        if(this!=&bt)
        {
            __DestroyBinaryTree(_pRoot);
            _pRoot=_CopyBinaryTree(bt._pRoot);
        }
        return *this;
    }
    void PreOrder()//前序遍历
    {
        cout<<"PreOrder:"<<endl;
        _PreOrder(_pRoot);
        cout<<endl;
    }
    void InOrder()//中序遍历
    {
        cout<<"InOrder:"<<endl;
        _InOrder(_pRoot);
        cout<<endl;
    }
    void PostOrder()//后序遍历
    {
        cout<<"PostOrder:"<<endl;
        _PostOrder(_pRoot);
        cout<<endl;
    }
    void LevelOrder()
    {
        if(NULL==_pRoot)
            return;
        queue<Node*> q;
        q.push(_pRoot);
        cout<<"LevelOrder:"<<endl;
        while(!q.empty())//队列不为空
        {
            Node* pCur=q.front();//取队头元素
            if(pCur->_pLeft)
                q.push(pCur->_pLeft);//取左子树
            if(pCur->_pRight)
                q.push(pCur->_pRight);//取右子树
            cout<<pCur->_value<<" ";//访问队头
            q.pop();//出队列
        }
        cout<<endl;
    }
    Node* Find(const T& value)//找二叉树中某个结点
    {

        Node* pCur=NULL;
        pCur=_Find(_pRoot,value);
        cout<<pCur->_value<<endl;
        return pCur;
    }
    Node* Parent(Node* pCur)//寻找双亲结点
    {
        Node* result=NULL;
        result=_Parent(_pRoot,pCur);
        cout<<"Parent:"<<endl;
        cout<<result->_value<<endl;
        return result;
    }
    Node* LeftChild(Node* pCur)//寻找左孩子结点
    {
        Node* result=NULL;
        result=_LeftChild(_pRoot,pCur);
        cout<<"LeftChild:"<<endl;
        cout<<result->_value<<endl;
        return result;
    }
    Node* RightChild(Node* pCur)//寻找右孩子结点
    {
        Node* result=NULL;
        result=_RightChild(_pRoot,pCur);
        cout<<"RightChild:"<<endl;
        cout<<result->_value<<endl;
        return result;
    }
    size_t Height()//计算二叉树的深度
    {
        size_t depth=0;
        depth=_Height(_pRoot);
        cout<<"Height:"<<depth<<endl;      
        return depth;
    }
    size_t GetLeefCount()
    {
        size_t count=0;
        count=_GetLeefCount(_pRoot);
        cout<<"leefcount: "<<count<<endl;       
        return count;
    }
    size_t GetKLevelCount(size_t k)
    {
        size_t count=0;
        count=_GetKLevelCount(_pRoot, k);
        cout<<"KLevelCount: "<<count<<endl;       
        return count;
    }
    void BinaryMirror_Nor()
    {
        if(NULL==_pRoot)
            return;
        queue<Node*> q;
        q.push(_pRoot);
        while(!q.empty())
        {
            Node* pCur=q.front();
            if(pCur->_pLeft)
                q.push(pCur->_pLeft);
            if(pCur->_pRight)
                q.push(pCur->_pRight);
            std::swap(pCur->_pLeft,pCur->_pRight);
            q.pop();
        }
    }
    void BinaryMirror()
    {
        _BinaryMirror(_pRoot);
    }
private:
    void _CreateBinaryTree(Node* &pRoot,const T array[],size_t size,size_t& index,const T& invalid)
    {
        if(index<size&&invalid!=array[index])
        {
            pRoot=new Node(array[index]);
            _CreateBinaryTree(pRoot->_pLeft,array,size,++index,invalid);//创建左子树
            _CreateBinaryTree(pRoot->_pRight,array,size,++index,invalid);//创建右子树
        }
    }
    Node* _CopyBinaryTree(Node* pRoot)//拷贝
    {
        Node* pNewRoot=NULL;
        if(pRoot)
        {
            //拷贝根节点
            pNewRoot=new Node(pRoot->_value);
            //拷贝左子树
            pNewRoot->_pLeft=_CopyBinaryTree(pRoot->_pLeft);
            //拷贝右子树
            pNewRoot->_pRight=_CopyBinaryTree(pRoot->_pRight);
        }
        return pNewRoot;
    }
    void _PreOrder(Node* pRoot)//前序遍历
    {
        if(pRoot)
        {
            cout<<pRoot->_value<<" ";
            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }
    void _InOrder(Node* pRoot)//中序遍历
    {
        if(pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout<<pRoot->_value<<" ";
            _InOrder(pRoot->_pRight);
        }
    }
    void _PostOrder(Node* pRoot)//后序遍历
    {
        if(pRoot)
        {   
            _PostOrder(pRoot->_pLeft);
            _PostOrder(pRoot->_pRight);
            cout<<pRoot->_value<<" ";
        }
    }
    void _DestroyBinaryTree(Node* &pRoot)
    {
        if(pRoot)
        {
            _DestroyBinaryTree(pRoot->_pLeft);
            _DestroyBinaryTree(pRoot->_pRight);
            delete pRoot;
            pRoot=NULL;
        }
    }
    Node* _Find(Node* pRoot,const T& value)//根据值寻找二叉树中的相应结点
    {
        if(NULL==pRoot)
            return NULL;
        if(pRoot->_value==value)
            return pRoot;   
        Node* pCur=NULL;
        if(pCur=_Find(pRoot->_pLeft,value))
            return pCur;
        return _Find(pRoot->_pRight,value);

    }
    Node* _Parent(Node* pRoot,Node* pCur)//获取双亲,pRoot为根节点 
    {
        assert(pCur);
        if(pRoot==NULL||pCur==pRoot)
            return NULL;
        if((pCur==pRoot->_pLeft)||(pCur==pRoot->_pRight))
            return pRoot;
        Node* ret=NULL;
        if(ret=_Parent(pRoot->_pLeft,pCur))
            return ret;
        else
            return _Parent(pRoot->_pRight,pCur);
    }
    Node* _LeftChild(Node* pRoot,Node* pCur)
    {
        assert(pCur);
        if(pRoot!=NULL && pCur->_pLeft!=NULL)
            return pCur->_pLeft;
        Node* ret=NULL;
        if(ret=_LeftChild(pRoot->_pLeft,pCur))
            return ret;
        else
            return _LeftChild(pRoot->_pRight,pCur);

    }
    Node* _RightChild(Node* pRoot,Node* pCur)
    {
        assert(pCur);
        if(pRoot!=NULL && pCur->_pRight!=NULL)
            return pCur->_pRight;
        Node* ret=NULL;
        if(ret=_RightChild(pRoot->_pLeft,pCur))
            return ret;
        else
            return _RightChild(pRoot->_pRight,pCur);

    }
    size_t _Height(Node* pRoot)//计算二叉树的深度
    {
        int hl=0;
        int hr=0;
        int max=0;
        if(pRoot!=NULL)
        {
            hl=_Height(pRoot->_pLeft);
            hr=_Height(pRoot->_pRight);
            max=hl>hr?hl:hr;
            return max+1;
        }
        else
            return 0;
    }
    size_t _GetLeefCount(Node* pRoot)
    {
        if(pRoot==NULL)
            return 0;
        if(NULL==pRoot->_pLeft && NULL==pRoot->_pRight)
            return 1;
        return _GetLeefCount(pRoot->_pLeft)+_GetLeefCount(pRoot->_pRight);
    }
    size_t _GetKLevelCount(Node* pRoot,size_t k)
    {
        if(pRoot==NULL||k<1)
            return 0;
        if(k==1)
            return 1;
        return _GetKLevelCount(pRoot->_pLeft,k-1)+_GetKLevelCount(pRoot->_pRight,k-1);
    }
    void _BinaryMirror(Node* pRoot)
    {
        if(pRoot)
        {
            std::swap(pRoot->_pLeft,pRoot->_pRight);
            _BinaryMirror(pRoot->_pLeft);
            _BinaryMirror(pRoot->_pRight);
        }
    }
private:
    Node* _pRoot;
};

void Test()
{
    char* pStr="124###35##6";
    BinaryTree<char> bt1(pStr,strlen(pStr),'#');

    bt1.PreOrder();
    bt1.InOrder();
    bt1.PostOrder();
    //bt1.LevelOrder();
    //bt1.Find('5');
    //bt1.Parent(bt1.Find('5'));
    //bt1.LeftChild(bt1.Find('1'));
    //bt1.RightChild(bt1.Find('1'));
    //bt1.Height();
    //bt1.GetLeefCount();
    //bt1.GetKLevelCount(4);
    //bt1.BinaryMirror_Nor();
    bt1.BinaryMirror(); 

    /*cout<<endl;

    BinaryTree<char> bt2(bt1);
    bt2.PreOrder();
    bt2.InOrder();
    bt2.PostOrder();
    cout<<endl;

    BinaryTree<char> bt3=bt1;
    bt3.PreOrder();
    bt3.InOrder();
    bt3.PostOrder();*/
}

int main()
{
    Test();
    return 0;
}
出走刺猬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树查找双亲结点
qq_43527713的博客
11-15 1万+
//递归实现查找双亲结点 void Find_Father(BiTNode *(&T),ElemType data) { if(T ==NULL) return; if(T->lchild != NULL)//当左孩子存在的时候才进行判断，否则程序出错 { if(T->lchild->data == data)...
二叉树入门
JavaBoy_XZL的博客
12-24 5021
树的基本定义 树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就 是说它是根朝上，而叶朝下的。 树具有以下特点： 1.每个结点有零个或多个子结点； 2.没有父结点的结点为根结点； 3.每一个非根结点只有一个父结点； 4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树； 树的相关术语 结点的度： 一个结点含有的子树的个数称为该结点的度； 叶结点： 度为0的结点称为叶结点，也可以叫做终端结点 分支.
二叉树递归C语言版
11-16
二叉树的递归算法，注释详细
关于二叉查找树如何获取其双亲结点的方法
ye_little_white的博客
12-16 4931
关于二叉查找树如何获取其双亲结点的方法 二叉树结构体的定义如下 struct binaryTree; typedef struct binaryTree { int value; binaryTree* LeftChild; binaryTree* RightChild; }TreeNode; 以下是如何获取双亲结点的具体代码 TreeNode* Parent_LinkedList(TreeNode* node) {
二叉树插入算法--递归
皮皮不调皮的博客
08-20 2011
对于BST而言，插入一个节点主要是要保持其“小-中-大”的逻辑不变，因此插入的节点的逻辑可以从根节点开始，一步步寻找新节点的“最终归宿”，比如在如下BST中，要插入新节点16，最终应该插入到节点17的左孩子处。 在实现插入算法的时候，由于树状结构本身是递归的，因此可以使用递归函数更优雅地实现插入算法。如下： 情况①: 第一次插入节点给这个二叉树 二叉树是空的,则直接把Root根指针指向新节点 struct node *Root=NULL; Root = bstInsert(Root,25); 对应插入代码
二叉树前序遍历--递归
he_xin2009的专栏
04-14 1972
二叉树遍历、前序遍历、递归、入栈、出栈
二叉树基本操作
04-30
3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和最小值。 4、（选作内容）试编写按层次顺序遍历二叉树的算法。参考算法思想：要采用一个队列q，先将二叉...
数据结构-二叉树递归-非递归实现
04-26
数据结构实验二叉树用递归实现先序遍历、中序遍历和后序遍历，用几种不同非递归方法实现了中序遍历，代码附有详细注释
二叉树的操作--递归非递归遍历、结点个数、树深度
12-10
先序递归遍历二叉树: a b c 先序非递归遍历二叉树: a b c 中序递归遍历二叉树: b a c 中序非递归遍历二叉树: b a c 后序递归遍历二叉树: b c a 后序非递归遍历二叉树: b c a 二叉树的深度是2 二叉树的结点个数...
qingq0825#Javabook-Interview#算法-二叉树-递归-二叉树反转1
07-25
原二叉树：反转后的二叉树：TreeNode temp = root.left;欢迎光临我的博客，发现更多技术资源~
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。
07-01
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，...
寻找二叉树双亲结点
gy77
02-25 3797
/* * @Issue: 寻找X结点的双亲结点 * @Author: 一届书生 * @LastEditTime: 2020-02-25 16:50:27 */ #include<iostream> using namespace std; #define type char typedef struct node{ type data; node ...
二叉树基本操作实现及总结（适合复习）
努力做个书呆儿
01-01 4004
建立二叉树的方法有递归–前缀表达式；非递归–括号+逗号 在此基础上可完成孩子兄弟链表的非递归构建 数据结构 typedef struct BTNode{ char data; struct BTNode *lchild,*rchild; }BTNode,*BTree; 建二叉树 前缀表达式（递归） //递归建树：仅前序成功？测试数据：ABD##EG###C#F## //后序：##D##G#E...
搜索二叉树递归操作
Hanani_Jia的博客
05-08 1560
 之前给大家介绍了搜索二叉树的非递归算法，今天给大家介绍一些搜索二叉树的递归算法的操作。  这里主要介绍的是插入，查找和删除。其实插入和之前的二叉树的操作是一样的，不过依然是需要判断你要查入的元素应当插入的位置。int BSTreeInsertR(BSTreeNode** tree, DataType x) { if (*tree == NULL) { *tree = BuyBSTreeN...
【二叉树】45 二叉树：结点个数
windyuan~
02-25 496
问题描述 : 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）基本操作17：在二叉树的二叉链表存储形式建立的基础上，使用递归的程序设计方法，设计并完成统计结点个数的算法。完成后将其加入到二.
AVL树的四种旋转--初步解析
hm108106的博客
05-25 6473
> AVL树也叫作平衡树，它的每个节点 都有平衡因子： 平衡因子=右子树的高度-左子树的高度 AVL树的性质： 平衡因子大小为（-2,2），即-1,0,1 当一个节点插入后可能导致AVL树的不平衡，因此需要经过旋转，让这棵树满足AVL树的性质： 一共有四种旋转方式，分别对应插入节点后的四种情况： 1.左单旋： 2.右单旋： 3.左右双旋： 先进行左单旋，再进行右单旋
使用栈存储后缀表达式
hm108106的博客
05-04 446
12*（3+4）-6+8/2的后缀表达式为：12 3 4 + * 6 - 8 2 / + 使用栈模拟存储后缀表达式：#include<iostream> #include<stack> using namespace std;enum OPERATOR//使用枚举类型 { DATA, ADD, SUB, MUL, DIV };struct Cell {
二叉树遍历递归算法的基本思路
最新发布
05-29
递归算法是最常见的实现方式，其基本思路如下： 1. 前序遍历：先访问根节点，然后递归遍历左子树和右子树。 具体实现步骤为： - 如果当前节点为空，则返回。 - 访问当前节点。 - 递归遍历左子树。 - 递归遍历右子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值