二叉树部分相关练习题

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

二叉树：一颗二叉树是节点的的一个有限集合，此集合可为空可由一个根节点及左子树、右子树组成。
下面为二叉树部分的相关习题：
1.创建二叉树
这里写图片描述

#include<iostream>
#include<queue>
#include<stack>
using namespace std;
//给出结点
template<class T>
struct BinTreeNode
{
    BinTreeNode<T>*_pLeft;//左子树
    BinTreeNode<T>*_pRight;//右子树
    T _data;
    BinTreeNode(const T&data)//构造函数
        :_pLeft(NULL)
        , _pRight(NULL)
        , _data(data)
    {}
};
template<class T>
class BinTree
{
    typedef BinTreeNode<T>*pNode;
    typedef BinTreeNode<T>Node;
public:
    BinTree()
        :_pRoot(NULL)
    {}
    BinTree(const T*array, size_t size, const T&invalid)//构造函数
    {
        size_t index = 0;
        CreateBinTree(_pRoot, array, size, index, invalid);
    }
创建二叉树的相关代码：
private:
    void CreateBinTree(pNode&pRoot, const T*array, size_t size, size_t &index, const T&invalid)//二叉树的建立
    {
        //先进行判断
        if (index < size&&'#' != array[index])
        {
             pRoot = new Node(array[index]);//创建根结点
            //创建左子树
            CreateBinTree(pRoot->_pLeft, array, size, ++index, invalid);
            //创建右子树
            CreateBinTree(pRoot->_pRight, array, size, ++index, invalid);
        }
    }
    pNode _pRoot;
};

2.前/中/后遍历二叉树（递归&非递归）
前序遍历顺序依次为：根节点—》左子树—》右子树
中序遍历顺序依次为:左子树—》根节点—》右子树
后序遍历顺序依次为：左子树—》右子树—》根节点
具体实现如下所示：

（三种遍历方式的递归形式：）
void preorder()
    {
        cout << "前序遍历：";
        _preorder(_pRoot);
        cout << endl;
    }
    void _preorder(pNode pRoot)//前序遍历的实现
    {
        if (pRoot)
        {
            cout << pRoot->_data << " ";
            _preorder(pRoot->_pLeft);
            _preorder(pRoot->_pRight);
        }
    }
    void midorder()
    {
        cout << "中序遍历：";
        _midorder(_pRoot);
        cout << endl;
    }
    void _midorder(pNode pRoot)//中序遍历的实现
    {
        if (pRoot)
        {
            _midorder(pRoot->_pLeft);
            cout << pRoot->_data << " ";
            _midorder(pRoot->_pRight);
        }
    }
    void pNextorder()
    {
        cout << "后序遍历" << " ";
        _pNextorder(_pRoot);
        cout << endl;
    }
    void _pNextorder(pNode pRoot)//后序遍历的实现
    {
        if (pRoot)
        {
            _pNextorder(pRoot->_pLeft);
            _pNextorder(pRoot->_pRight);
            cout << pRoot->_data << " ";
        }
    }

下为三种遍历方式的非递归形式：
前序遍历的非递归应用栈，由于栈的特性是先进的后出，故先将根节点入栈，再将右子树入栈，最后将左子树入栈。

void preorder_nor()
    {
        cout << "前序遍历的非递归：";
        _preorder_nor(_pRoot);
        cout << endl;
    }
    void _preorder_nor(pNode pRoot)//前序遍历非递归的实现
    {
        if (_pRoot == NULL)
        {
            return;
        }
        stack<pNode>s;
        s.push(_pRoot);
        while (!s.empty())
        {
            pNode pTop = s.top();
            cout << pTop->_data << "";
              s.pop();
              if (pTop->_pRight)
              {
                  s.push(pTop->_pRight);
              }
              if (pTop->_pLeft)
              {
                  s.push(pTop->_pLeft);
              }
        }
    }

中序遍历的非递归应用栈，将找到当前节点为根的左侧路径中的节点压入栈中，取到栈顶对其进行访问，再将右子树压入栈中。具体实现如下：

void midorder_nor()
    {
        cout << "二叉树的中序遍历非递归：";
        _midorder_nor(_pRoot);
        cout << endl;
    }
    void _midorder_nor(pNode pRoot)//中序非递归的实现
    {
        if (pRoot == NULL)
        {
            return;
        }
        stack<pNode>s;
        pNode cur = _pRoot;
        //1.找到当前节点为根的左侧路径中的节点
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_pLeft;//将其左侧的节点中的元素压入栈中
            }
            //取出栈顶元素并进行访问
            cur = s.top();
            cout << cur->_data << " ";
            s.pop();
            //将右子树压入栈中
            cur = cur->_pRight;
        }
    }

后序遍历的非递归应用栈，将找到当前节点为根的左侧路径中的节点压入栈中，取到栈顶对其进行访问，再将右子树压入栈中。但是与中序不同的是要给其初始化一个prev指针，记录已经访问过的节点具体实现如下：

void pNextorder_nor()
    {
        cout << "后序遍历非递归：";
        _pNextorder_nor(_pRoot);
        cout << endl;
    }
    void _pNextorder_nor(pNode pRoot)//后序遍历非递归
    {
        if (_pRoot == NULL)
        {
            return;
        }
        stack<pNode>s;
        pNode pcur = _pRoot;
        pNode prev = NULL;
        while (pcur || !s.empty())
        {
            while (pcur)
            {
                s.push(pcur);
                pcur = pcur->_pLeft;
            }
            if (!s.empty())
            {
                pcur = s.top();
            }
            if (pcur->_pRight == NULL || pcur->_pRight == prev)
            {
                cout << pcur->_data << " ";
                prev = pcur;//将当前结点地址赋值pre作为下一次判断标志，防止重复访问  
                s.pop();
                pcur = NULL;
            }
            else
                pcur = pcur->_pRight;
        }
    }

3.层序遍历二叉树
层序遍历的基本思想为：因为要进行一层一层遍历，故应用队列，队列的特点是先进先出，所以先将根节点如队列，进行访问，之后是左子树。右子树。具体实现如下：

void Levelorder()//层序遍历
    {
        cout << "层序遍历" << " ";
        _Levelorder();
        cout << endl;
    }
    void _Levelorder()//层序遍历的实现(应用了队列，先进先出）
    {
        if (_pRoot == NULL)
        {
            return;
        }
        queue<pNode>q;//定义一个队列
        q.push(_pRoot);//根节点入队
        while (!q.empty())
        {
            pNode cur = q.front(); //将队头取出
            cout << cur->_data << " ";
            if (cur->_pLeft)
            {
                q.push(cur->_pLeft);//左子树入队
            }
            if (cur->_pRight)
            {
                q.push(cur->_pRight);//右子树入队
            }
            q.pop();
        }
        cout << endl;
    }

4.求二叉树高度
二叉树的高度为：左子树的高度右子树高度的最大值+1。
具体实现如下：

    size_t Height()
    {
        cout << "二叉树的高度为：";
        return _Height(_pRoot);
    }
   size_t _Height(pNode pRoot)//二叉树的高度
    {
        if (pRoot == NULL)
        {
            return 0;
        }
        if (pRoot->_pLeft == NULL&&pRoot->_pRight == NULL)
        {
            return 1;
        }
        size_t leftHeight = _Height(pRoot->_pLeft);
        size_t rightHeight = _Height(pRoot->_pRight);
        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }

5.求二叉树中节点的个数
二叉树中节点个数为左子树节点个数+右子树节点个数+根节点
具体实现如下：

    size_t size()
    {
        cout << "二叉树节点个数为：";
        return Size(_pRoot);
    }
    size_t Size(pNode pRoot)//二叉树节点个数
    {
        if (NULL == pRoot)
            return 0;
        return Size(pRoot->_pLeft) + Size(pRoot->_pRight) + 1;
    }

6.求叶子节点的个数
叶子节点为没有左右子树的节点，具体分为三种情况：
（1）、空树——-返回0
（2）、只有一个根节点—-返回1
（3）、含有多个节点—–则为左右子树叶子节点之和
具体实现如下：

    size_t GetLeefCount()
    {
        cout << "二叉树中叶子节点个数：";
        return _GetLeefCount(_pRoot);
    }
   size_t _GetLeefCount(pNode pRoot)//二叉树叶子节点的个数
    {
        if (pRoot == NULL)
        {
            return 0;
        }
        if (pRoot->_pLeft == NULL&&pRoot->_pRight == NULL)
        {
            return 1;
        }
        return _GetLeefCount(pRoot->_pLeft) + _GetLeefCount(pRoot->_pRight);
    }

7.求二叉树中第K层节点的个数
求第K层的节点个数也分为三种情况：
（1）、空树或者K<=0——-返回0
（2）、只有一个根节点—-返回1
（3）、含有多个节点—–则为第K-1层的左右子树节点相加
具体实现如下所示：

    size_t GetKcount(size_t k)
    {
        cout << "二叉树第K层节点个数";
        return _GetKcount(_pRoot, k);
    }
    size_t  _GetKcount(pNode pRoot, size_t k)//二叉树中第K层的节点个数
    {
        if (pRoot == NULL || k <= 0)
        {
            return 0;
        }
        if (k == 1)
        {
            return 1;
        }
        return _GetKcount(pRoot->_pLeft, k - 1) + _GetKcount(pRoot->_pRight, k - 1);//上一层的左右节点之和
    }

8.在此二叉树中找一个节点
具体实现如下：

pNode Find(const T&data)
    {
        //cout << "找的节点为：";
        return _Find(_pRoot, data);
    }
    pNode _Find(pNode pRoot, const T&data)//找一个节点
    {
        if (pRoot == NULL)
        {
            return NULL;
        }
        /*if (pRoot->_data == data)
        {
            return pRoot;
        }
        pNode ret = NULL;
        if (ret == (_Find(pRoot->_pLeft, data)))
        {
            return ret;
        }
        return _Find(_pRoot->_pRight, data);*/
        if (data == pRoot->_data)
            return pRoot;
        if (pRoot->_pLeft)
        {
            _Find(pRoot->_pLeft, data);
        }
        if (pRoot->_pRight)
        {
            _Find(pRoot->_pRight, data);
        }
    }

9.找寻双亲节点与节点的左右孩子

pNode parent(pNode pNode)
    {
        cout << "该节点的双亲节点为：";
        return _parent(_pRoot, pNode);
    }
    pNode _parent(pNode pRoot, pNode pNode)
    {
        if (pRoot == pNode || pRoot == NULL || pNode == NULL)
        {
             return NULL;
        }
        if (pRoot == pNode || pRoot == NULL || pNode == NULL)
         {
           return NULL;
         }
        if (pNode == pRoot->_pLeft || pNode == pRoot->_pRight)
            return pRoot;
        if (pRoot->_pLeft)
        {
            _parent(pRoot->_pLeft, pNode);
        }
        if (pRoot->_pRight)
        {
            _parent(pRoot->_pRight, pNode);
        }
        return pRoot;
    }
    pNode Leftchild(pNode pNode)
    {
        cout << "该节点的左孩子为：";
        return (NULL == pNode) ? NULL : pNode->_pLeft;
    }

    pNode Rightchild(pNode pNode)
    {
        cout << "该节点的右孩子为：";
        return (NULL == pNode) ? NULL : pNode->_pRight;
    }

10.求二叉树的镜像
所谓镜像即为在镜子中的像，具体的实现方式如同前序遍历
这里写图片描述
故将左右子树进行交换。
具体实现如下所示：

void mirrorBinTree()
    {
        cout << "二叉树的镜像：";
        _mirrorBinTree(_pRoot);
        cout << endl;
    }
    void _mirrorBinTree(pNode pRoot)
    {
        if (pRoot == NULL)
            return;
        if (pRoot)
        {
            swap(pRoot->_pLeft, pRoot->_pRight);
            cout << pRoot->_data << "";
        }
        _mirrorBinTree(pRoot->_pLeft);
        _mirrorBinTree(pRoot->_pRight);
    }

11.判断一颗二叉树是否为完全二叉树
具体分析：
1.空树—-是
2.1个节点—–是
3.多个节点（先将根节点记录，如pNode pCur = _pRoot;）
（1）、左右子树均存在
（2）、只有左子树没有右子树
（3）、只有右子树没有左子树
（4）、没有左右子树

bool IscompleteBinTree()
    {
        return _IscompleteBinTree(_pRoot);
    }
    bool _IscompleteBinTree(pNode pRoot)//判断是否为完全二叉树
    {
        if (pRoot == NULL || (pRoot->_pLeft == NULL&&pRoot->_pRight == NULL))
            return true;
        //讨论多个节点的情况下：
        queue<pNode>q;
        pNode pCur = _pRoot;
        bool result = false;//最终的返回结果
        bool flag = false;//给出一个临界点
        while (!q.empty())
        {
            pCur = q.front();
            if (flag)//只有存在临界点时，对其进行讨论
            {
                if (pCur->_pLeft || pCur->_pRight)
                    return false;                                   
            }
            else
            {
                //以下的四种情况在讨论临界点是否存在（与层序遍历相似）
                if (pCur->_pLeft&&pCur->_pRight)
                {
                    q.push(pCur->_pLeft);
                    q.push(pCur->_pRight);
                }
                else if (pCur->_pLeft)
                {
                    q.push(pCur->_pLeft);
                    flag = true;
                }
                else if (pCur->_pRight)
                {
                  result=false;//说明这棵树不是完全二叉树
                }
                else
                    flag= true;
            }
            q.pop();
        }
        return  result;
    }

另外，后序遍历在销毁空间时使用

    void DestoryBinTree(pNode pRoot)//销毁空间
    {
        if (pRoot)
        {
            DestoryBinTree(pRoot->_pLeft);
            DestoryBinTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }

具体的代码如下：

#include<iostream>
#include<queue>
#include<stack>
using namespace std;
//给出结点
template<class T>
struct BinTreeNode
{
    BinTreeNode<T>*_pLeft;
    BinTreeNode<T>*_pRight;
    T _data;
    BinTreeNode(const T&data)//构造函数
        :_pLeft(NULL)
        , _pRight(NULL)
        , _data(data)
    {}
};
template<class T>
class BinTree
{
    typedef BinTreeNode<T>*pNode;
    typedef BinTreeNode<T>Node;
public:
    BinTree()
        :_pRoot(NULL)
    {}
    BinTree(const T*array, size_t size, const T&invalid)//构造函数
    {
        size_t index = 0;
        CreateBinTree(_pRoot, array, size, index, invalid);
    }
    BinTree(const BinTree<T>&bt)//拷贝构造函数
    {
        _pRoot = copyBinTree(bt._pRoot);
    }
    BinTree<T>&operator=(const BinTree<T>&bt)//赋值运算符重载
    {
        if (this != &bt)
        {
            DestoryBinTree(_pRoot);
            _pRoot = copyBinTree(bt._pRoot);
        }
        return *this;
    }
    ~BinTree()//析构函数
    {
        DestoryBinTree(_pRoot);
    }
    void preorder()
    {
        cout << "前序遍历：";
        _preorder(_pRoot);
        cout << endl;
    }
    void _preorder(pNode pRoot)//前序遍历的实现
    {
        if (pRoot)
        {
            cout << pRoot->_data << " ";
            _preorder(pRoot->_pLeft);
            _preorder(pRoot->_pRight);
        }
    }
    void preorder_nor()
    {
        cout << "前序遍历的非递归：";
        _preorder_nor(_pRoot);
        cout << endl;
    }
    void _preorder_nor(pNode pRoot)//前序遍历非递归的实现
    {
        if (_pRoot == NULL)
        {
            return;
        }
        stack<pNode>s;
        s.push(_pRoot);
        while (!s.empty())
        {
            pNode pTop = s.top();
            cout << pTop->_data << "";
              s.pop();
              if (pTop->_pRight)
              {
                  s.push(pTop->_pRight);
              }
              if (pTop->_pLeft)
              {
                  s.push(pTop->_pLeft);
              }
        }
    }
    void midorder()
    {
        cout << "中序遍历：";
        _midorder(_pRoot);
        cout << endl;
    }
    void _midorder(pNode pRoot)//中序遍历的实现
    {
        if (pRoot)
        {
            _midorder(pRoot->_pLeft);
            cout << pRoot->_data << " ";
            _midorder(pRoot->_pRight);
        }
    }
    void midorder_nor()
    {
        cout << "二叉树的中序遍历非递归：";
        _midorder_nor(_pRoot);
        cout << endl;
    }
    void _midorder_nor(pNode pRoot)//中序非递归的实现
    {
        if (pRoot == NULL)
        {
            return;
        }
        stack<pNode>s;
        pNode cur = _pRoot;
        //1.找到当前节点为根的左侧路径中的节点
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_pLeft;//将其左侧的节点中的元素压入栈中
            }
            //取出栈顶元素并进行访问
            cur = s.top();
            cout << cur->_data << " ";
            s.pop();
            //将右子树压入栈中
            cur = cur->_pRight;
        }
    }
    void pNextorder()
    {
        cout << "后序遍历" << " ";
        _pNextorder(_pRoot);
        cout << endl;
    }
    void _pNextorder(pNode pRoot)//后序遍历的实现
    {
        if (pRoot)
        {
            _pNextorder(pRoot->_pLeft);
            _pNextorder(pRoot->_pRight);
            cout << pRoot->_data << " ";
        }
    }
    void pNextorder_nor()
    {
        cout << "后序遍历非递归：";
        _pNextorder_nor(_pRoot);
        cout << endl;
    }
    void _pNextorder_nor(pNode pRoot)//后序遍历非递归
    {
        if (_pRoot == NULL)
        {
            return;
        }
        stack<pNode>s;
        pNode pcur = _pRoot;
        pNode prev = NULL;
        while (pcur || !s.empty())
        {
            while (pcur)
            {
                s.push(pcur);
                pcur = pcur->_pLeft;
            }
            if (!s.empty())
            {
                pcur = s.top();
            }
            if (pcur->_pRight == NULL || pcur->_pRight == prev)
            {
                cout << pcur->_data << " ";
                prev = pcur;//将当前结点地址赋值pre作为下一次判断标志，防止重复访问  
                s.pop();
                pcur = NULL;
            }
            else
                pcur = pcur->_pRight;
        }
    }
    void Levelorder()//层序遍历
    {
        cout << "层序遍历" << " ";
        _Levelorder();
        cout << endl;
    }
    void _Levelorder()//层序遍历的实现(应用了队列，先进先出）
    {
        if (_pRoot == NULL)
        {
            return;
        }
        queue<pNode>q;//定义一个队列
        q.push(_pRoot);//根节点入队
        while (!q.empty())
        {
            pNode cur = q.front(); //将队头取出
            cout << cur->_data << " ";
            if (cur->_pLeft)
            {
                q.push(cur->_pLeft);//左子树入队
            }
            if (cur->_pRight)
            {
                q.push(cur->_pRight);//右子树入队
            }
            q.pop();
        }
        cout << endl;
    }
    void mirrorBinTree()
    {
        cout << "二叉树的镜像：";
        _mirrorBinTree(_pRoot);
        cout << endl;
    }
    void _mirrorBinTree(pNode pRoot)
    {
        if (pRoot == NULL)
            return;
        if (pRoot)
        {
            swap(pRoot->_pLeft, pRoot->_pRight);
            cout << pRoot->_data << "";
        }
        _mirrorBinTree(pRoot->_pLeft);
        _mirrorBinTree(pRoot->_pRight);
    }
    bool IscompleteBinTree()
    {
        return _IscompleteBinTree(_pRoot);
    }
    bool _IscompleteBinTree(pNode pRoot)//判断是否为完全二叉树
    {
        if (pRoot == NULL || (pRoot->_pLeft == NULL&&pRoot->_pRight == NULL))
            return true;
        //讨论多个节点的情况下：
        queue<pNode>q;
        pNode pCur = _pRoot;
        bool result = false;//最终的返回结果
        bool flag = false;//给出一个临界点
        while (!q.empty())
        {
            pCur = q.front();
            if (flag)//只有存在临界点时，对其进行讨论
            {
                if (pCur->_pLeft || pCur->_pRight)
                    return false;                                   
            }
            else
            {
                //以下的四种情况在讨论临界点是否存在（与层序遍历相似）
                if (pCur->_pLeft&&pCur->_pRight)
                {
                    q.push(pCur->_pLeft);
                    q.push(pCur->_pRight);
                }
                else if (pCur->_pLeft)
                {
                    q.push(pCur->_pLeft);
                    flag = true;
                }
                else if (pCur->_pRight)
                {
                  result=false;//说明这棵树不是完全二叉树
                }
                else
                    flag= true;
            }
            q.pop();
        }
        return  result;
    }
    size_t size()
    {
        cout << "二叉树节点个数为：";
        return Size(_pRoot);
    }
    size_t GetLeefCount()
    {
        cout << "二叉树中叶子节点个数：";
        return _GetLeefCount(_pRoot);
    }
    size_t GetKcount(size_t k)
    {
        cout << "二叉树第K层节点个数";
        return _GetKcount(_pRoot, k);
    }
    size_t Height()
    {
        cout << "二叉树的高度为：";
        return _Height(_pRoot);
    }
    pNode Find(const T&data)
    {
        //cout << "找的节点为：";
        return _Find(_pRoot, data);
    }
    pNode parent(pNode pNode)
    {
        cout << "该节点的双亲节点为：";
        return _parent(_pRoot, pNode);
    }
    pNode Leftchild(pNode pNode)
    {
        cout << "该节点的左孩子为：";
        return (NULL == pNode) ? NULL : pNode->_pLeft;
    }
    pNode Rightchild(pNode pNode)
    {
        cout << "该节点的右孩子为：";
        return (NULL == pNode) ? NULL : pNode->_pRight;
    }
    size_t Size(pNode pRoot)//二叉树节点个数
    {
        if (NULL == pRoot)
            return 0;
        return Size(pRoot->_pLeft) + Size(pRoot->_pRight) + 1;
    }
    size_t _GetLeefCount(pNode pRoot)//二叉树叶子节点的个数
    {
        if (pRoot == NULL)
        {
            return 0;
        }
        if (pRoot->_pLeft == NULL&&pRoot->_pRight == NULL)
        {
            return 1;
        }
        return _GetLeefCount(pRoot->_pLeft) + _GetLeefCount(pRoot->_pRight);
    }
    size_t  _GetKcount(pNode pRoot, size_t k)//二叉树中第K层的节点个数
    {
        if (pRoot == NULL || k <= 0)
        {
            return 0;
        }
        if (k == 1)
        {
            return 1;
        }
        return _GetKcount(pRoot->_pLeft, k - 1) + _GetKcount(pRoot->_pRight, k - 1);//上一层的左右节点之和
    }
    size_t _Height(pNode pRoot)//二叉树的高度
    {
        if (pRoot == NULL)
        {
            return 0;
        }
        if (pRoot->_pLeft == NULL&&pRoot->_pRight == NULL)
        {
            return 1;
        }
        size_t leftHeight = _Height(pRoot->_pLeft);
        size_t rightHeight = _Height(pRoot->_pRight);
        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }
    pNode _Find(pNode pRoot, const T&data)//找一个节点
    {
        if (pRoot == NULL)
        {
            return NULL;
        }
        /*if (pRoot->_data == data)
        {
            return pRoot;
        }
        pNode ret = NULL;
        if (ret == (_Find(pRoot->_pLeft, data)))
        {
            return ret;
        }
        return _Find(_pRoot->_pRight, data);*/
        if (data == pRoot->_data)
            return pRoot;
        if (pRoot->_pLeft)
        {
            _Find(pRoot->_pLeft, data);
        }
        if (pRoot->_pRight)
        {
            _Find(pRoot->_pRight, data);
        }
    }
    //pNode _parent(pNode pRoot, pNode pNode)//找寻pNode的双亲节点
    //{
    //  if (pRoot == pNode || pRoot == NULL || pNode == NULL)
    //  {
    //      return NULL;
    //  }
    //  if (pRoot->_pLeft == pNode || pRoot->_pRight == pNode)
    //  {
    //      return pRoot;
    //  }
    //  pNode parent=NULL;
    //  if (_parent(pRoot->_pLeft, pNode) == parent)
    //  {
    //      return parent;
    //  }
    //  if (_parent(pRoot->_pRight, pNode) == parent)
    //  {
    //      return parent;
    //  }
    //}
    pNode _parent(pNode pRoot, pNode pNode)
    {
        if (pRoot == pNode || pRoot == NULL || pNode == NULL)
        {
             return NULL;
        }
        if (pRoot == pNode || pRoot == NULL || pNode == NULL)
         {
           return NULL;
         }
        if (pNode == pRoot->_pLeft || pNode == pRoot->_pRight)
            return pRoot;
        if (pRoot->_pLeft)
        {
            _parent(pRoot->_pLeft, pNode);
        }
        if (pRoot->_pRight)
        {
            _parent(pRoot->_pRight, pNode);
        }
        return pRoot;
    }

    pNode copyBinTree(pNode pRoot)//拷贝函数
    {
        pNode pnewroot = NULL;
        if (pRoot)
        {
            pnewroot = new Node(pRoot->_data);//拷贝根节点
        }
            if (pRoot->_pLeft)
            {
                pnewroot->_pLeft = copyBinTree(pRoot->_pLeft);//拷贝左子树
            }
            if (pRoot->_pRight)
            {
                pnewroot->_pRight = copyBinTree(pRoot->_pRight);//拷贝右子树
            }
        return pnewroot;
    }
    void DestoryBinTree(pNode pRoot)//销毁空间
    {
        if (pRoot)
        {
            DestoryBinTree(pRoot->_pLeft);
            DestoryBinTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }
private:
    void CreateBinTree(pNode&pRoot, const T*array, size_t size, size_t &index, const T&invalid)//二叉树的建立
    {
        //先进行判断
        if (index < size&&'#' != array[index])
        {
             pRoot = new Node(array[index]);//创建根结点
            //创建左子树
            CreateBinTree(pRoot->_pLeft, array, size, ++index, invalid);
            //创建右子树
            CreateBinTree(pRoot->_pRight, array, size, ++index, invalid);
        }
    }
    pNode _pRoot;
};
void test()
{
    char array[] = "ABD###CE##F";
    BinTree<char>bt(array,strlen(array),'#');
    bt.preorder_nor();
    //bt.midorder();
    //bt.midorder_nor();
    //bt.pNextorder();
    //bt.pNextorder_nor();
    bt.mirrorBinTree();//
    bt.mirrorBinTree();//两次镜像显示就看它是否正确
    cout << boolalpha << bt.IscompleteBinTree() << endl;
    cout << bt.size() << endl;
    cout << bt.GetLeefCount() << endl;
    cout << bt.GetKcount(3) << endl;
    cout << bt.Height() << endl;
    cout << bt.parent(bt.Find('C'))->_data << endl;
    //cout << bt.Leftchild(bt.Find('A'))->_data << endl;
    cout << bt.Rightchild(bt.Find('A'))->_data << endl;
    BinTree<char>bt1(bt);//拷贝构造函数
    bt1.preorder();
    bt1.pNextorder();
    bt1.Levelorder();
    BinTree<char>bt2;//赋值
    bt2 = bt;
    bt2.preorder();
}
int main()
{
    test();
    system("pause");
    return 0;
}

这里写图片描述
希望各位能给与意见及建议。

xiaodu655
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【自考】数据结构导论—二叉树计算题
tina11241124的博客
04-29 5944
例题1：深度为6的满二叉树第5层有（ 16 ）节点； 解析：深度为N的满二叉树第M层节点数为2(k-1); 2(5-1)=24=16个节点 例题2：一棵完全二叉树上有1001个结点，其中叶子结点的个数是（ 501 ）； 解析：如果一棵完全二叉树的结点总数为n，那么叶子结点等于n/2（当n为偶数时）或者(n+1)/2（当n为奇数时） （1001+1）/2=501 例题3：高度为5的完全二叉树中最少有（16 ）个结点； 解析：完全二叉树第5层最少1个结点才是最少。深度为N的满二叉树共有..
二叉树综合练习
qq_52741431的博客
05-13 145
二叉树综合练习 文章目录二叉树综合练习什么是二叉树二叉树的三种遍历方式二叉树的常用操作 什么是二叉树 什么是树   树是一种非线性的数据结构，是一个有层次关系的集合，有一个特殊的节点叫做根节点，除根节点外其余的节点被分为n个互不相交的集合，每个集合又有一颗子树，每个子树的有且只有一个前驱节点，有0个或多个后继节点，树的概念是通过递归来定义的。 什么是二叉树   二叉树是一颗特殊的树，他的每个节点最多有两颗子树，也就是每个节点的度都不超过2，并且他的子树有左右之分。 什么是满二叉树   满二叉树是建立在二叉树
树与二叉树——有关计算的题目
fu_jian_ping的博客
05-05 2208
一、题目： 在度为4的树中，若有20个度为4的节点，10个度为3的节点，1个度为2的节点，10个度为1的节点，则树T的叶节点个数是？ 这道题是2010年计算机联考真题。我用手算（半蛮力）解出答案是82，结果是对的，但是耗时较长，而且如果数字再大点也不好算了，因此肯定存在一种更加高效的方法。 我们知道， 树的节点的个数=树的度+1 于是树的节点个数N = 1 + 20*4 + 10*3 + 1...
二叉树练习day.9
最新发布
u011381222的博客
04-13 1012
题目描述：给你二叉搜索树的根节点root，同时给定最小边界low和最大边界high。通过修剪二叉搜索树，使得所有节点的值在中。修剪树改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。可以证明，存在。所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。
二叉树经典练习题（基础）-- JAVA
weixin_45975659的博客
07-06 943
判定一棵树是否为完全二叉树 判定两棵树是否相同 判定两棵树是否有相同结构和节点值的子树 找出树的最大深度 判定一棵树是否为高度平衡的二叉树（一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1） 判定一棵树是否对称 判定一棵树是否镜像对称 import java.util.LinkedList; import java.util.Queue; class TreeNode { int val; TreeNode left; TreeNode right; Tre.
二叉树的题目练习总集（一次做到爽）
雀黑够呛哥
04-14 2728
摘要：建立二叉树、前中后层序、求树高度、叶子结点个数、k层结点个数、结点是否存在于二叉树、两个叶子最近公共祖先、判断平衡树、求二叉树最远两个结点距离。 目录 分析需求： 一、节点 二、队列 三、树 1、树的基本方法：建立二叉树。 2、求前中后层遍历 3、求树的高度： 4、求叶子节点个数 5、求二叉树第k层的结点个数 6、判断一个结点是否在二叉树中？ 7、求两个结点的...
人工智能练习题解读.doc
11-16
"人工智能练习题解读" 本资源摘要信息涵盖了人工智能领域的多个方面，包括人工智能的基本概念、知识表示方法、推理技术、搜索算法、专家系统、机器学习、计算智能等。本文档共包含23道填空题和6道选择题，涵盖了...
《CADCAM》练习题及答案.doc
02-17
《CAD/CAM》练习题及答案涵盖了计算机辅助设计与制造领域的多个知识点，这些知识点对于理解和掌握CAD/CAM系统至关重要。 1. 尺寸标注：一个完整的尺寸由尺寸线、尺寸界线、文本和箭头四部分组成。这是CAD中基本的...
构建二叉树_二叉树_
10-01
在给定的压缩包文件"构建二叉树"中，可能包含用于演示如何根据给定的前序、中序或后序序列构建二叉树的代码实例、解释或练习题。通过学习这些材料，你可以深入理解如何利用遍历序列来重建二叉树结构，这对于理解和...
erchashu.rar_交换 二叉树 左右子树_交换左右子树
09-19
在IT领域，二叉树是一种基础且重要的数据结构，它被广泛应用于算法设计和数据处理。本主题聚焦于“交换...在给定的场景中，`erchashu.doc` 文件可能包含了具体的二叉树示例和相关代码实现，可以进一步学习和研究。
数据结构树和二叉树习题.pdf
09-30
数据结构树和二叉树习题.pdf 是一份涵盖了树和二叉树相关知识点的习题集。下面是对标题、描述、标签和部分内容的详细解释和相关知识点总结： 一、树和二叉树的基本概念 * 树是一种数据结构，它是一组节点的集合，...
二叉树中的常见算法题
weixin_30243533的博客
05-06 146
1、二叉树的每个根节点到叶节点的路径代表一个数字，求所有根节点到叶节点所组成数字的和。 sum=12+13=25 1 int addsumnumber(BinTree *root,int sum) 2 { 3 if(root == NULL) 4 return 0; 5 if (root->left == 0 &&...
二叉树的经典例题—数据结构
m0_61963422的博客
11-09 3261
二叉树
【树和二叉树】—— 九道习题，难易结合，手把手掌握树的基本知识
weixin_52621323的博客
05-19 928
树，一个不太友好的家伙，今天就好好欺负欺负图论中的它
二叉树的几道典型例题
chenkaixin_1024的博客
05-02 3103
1.求二叉树的高度 int _GetTreeHight(Node* pRoot) { if(pRoot==NULL) return 0; if(pRoot->_pLeft==NULL&&pRoot->_pRight==NULL) return 1; int left=_GetTreeHight(pRoot->_pLeft)+1; int right=_GetTr
二叉树 （操作与一些节点计算题）
weixin_45765493的博客
03-30 970
二叉树的二叉链表结点结构定义 typedef struct BiTNode/*结点结构*/ { char data;//结点数据 struct BiTNode* lchild, * rchild;//左孩子，右孩子。 }BiTNode,*BiTree; 1.前序遍历 前序遍历的规则时若二叉树为空，则空操作返回，否则 先访问根节点，然后前序遍历左子树，在前序遍历右子树，如图： 这个二叉树的前...
二叉树计算题
qq_41685509的博客
09-21 1811
1.完全二叉树共有2∗N−12*N-12∗N−1个结点，则它的叶节点数是_____ 设n0n_0n0​为叶子结点的个数，n1n_1n1​为有一个孩子结点的结点个数，n2n_2n2​为有两个孩子结点的结点个数，mmm为二叉树边的条数 完全二叉树有偶数个结点，所以n1=0n_1=0n1​=0 n0+n2=2∗N−1n0+n2=2*N-1n0+n2=2∗N−1（共有2∗N−12*N-12∗N−1个结点） m=n0+n2−1m=n0+n2-1m=n0+n2−1（树的性质：边的个数=总结点数-1） n2∗2=mn2*
二叉树的高度和深度的理解
南风花海的博客
11-23 6047
高度：是从叶子结点起开始往上数层数，有多少层就是指该二叉树的高度是多少。 深度：是从根结点起开始往下数层数，有多少层就是指该二叉树的深度是多少。 总结：在数值上高度和深度是相等的，但是表示的含义却不相同。 例题：设某课二叉树的高度为10，则该二叉树上叶子结点最多有 512 个 高度为10，说明该二叉树有10层 第一层的结点个数为2的0次幂，第二层的结点个数最多为2的1次幂，依次类推 第k层上的结点最多为2的(k-1)次幂，将10带入k，得到结果2的9次幂，so第10层最多有512个结点 即该二
二叉树练习题
XHfight的博客
01-03 2167
1.将搜索二叉树转换成有序的双向链表 思路：由搜索二叉树的特点（左      中序递归，记录前一个结点（初始为空），前一个结点的右指向当前结点，当前结点的左指向前一个结点。 Node* ToOrderedDoubleList() //将搜索二叉树转换成有序的双向链表（递归） { Node* prev = NULL; Node* head = _root; while(head &&
数据结构（C语言版） 第五章 树与二叉树 知识梳理 + 作业习题详解1
08-04
在二叉树部分，首先介绍了二叉树的建立和存储方式。二叉树有两种存储方式：顺序存储和链式存储。顺序存储是使用一维数组来表示二叉树，通过数组下标来表示结点的位置；链式存储使用指针来表示二叉树的结点之间的关系...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值