C++实现二叉树的基本操作

最新推荐文章于 2024-07-25 08:38:10 发布
最新推荐文章于 2024-07-25 08:38:10 发布
阅读量606 收藏 3
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zl_8577/article/details/82080925
版权

BinTree.h文件

#pragma once
#pragma once
#include<iostream>
using namespace std;
#include<string.h>
#include<queue>
#include<stack>

template<class T>
struct BinTreeNode
{
    BinTreeNode(const T& data)
    :_data(data)
    , _left(NULL)
    , _right(NULL)
    {}

    BinTreeNode<T>* _left;
    BinTreeNode<T>* _right;
    T _data;
};

template<class T>
class BinTree
{
    typedef BinTreeNode<T> Node;
    typedef Node* pNode;
public:
    BinTree()
        :_pRoot(NULL)
    {}

    BinTree(const T* array, size_t size, const T& invalid)
    {
        size_t index = 0;
        _CreateBinTree(_pRoot, array, size, invalid, index);
    }

    BinTree(const BinTree<T>& bt)
        :_pRoot(NULL)
    {
        _pRoot = _CopyBinTree(bt._pRoot);
    }

    BinTree<T>& operator=(const BinTree<T>& bt)
    {
        if (this != &bt)
        {
            _DestoryBinTree(_pRoot);
            _pRoot = _CopyBinTree(bt._pRoot);
        }
        return *this;
    }

    ~BinTree()
    {
        if (_pRoot)
        {
            _DestoryBinTree(_pRoot);
        }
    }


    void PreOrder()//先序遍历
    {
        cout << "PreOrder:";
        _PreOrder(_pRoot);
        cout << endl;
        cout << "PreOrder1:";
        _PreOrder1(_pRoot);
        cout << endl;

        cout << "PreOrder2:";
        _PreOrder2(_pRoot);
        cout << endl;
    }


    void InOrder()//中序遍历
    {
        cout << "InOrder:";
        _InOrder(_pRoot);
        cout << endl;
        cout << "InOrder1:";
        _InOrder1(_pRoot);
        cout << endl;
    }


    void PostOrder()//后序遍历
    {
        cout << "PostOrder:";
        _PostOrder(_pRoot);
        cout << endl;
        cout << "PostOrder1:";
        _PostOrder1(_pRoot);
        cout << endl;
    }

    void Size()//统计结点的个数
    {
        cout << "结点的个数为：";
        size_t count1 = 0;
        _CountNode(_pRoot, count1);
        cout << count1 << endl;

        cout << "CountNode1：";
        cout << _CountNode1(_pRoot) << endl;
    }

    void LeftSize()//统计叶子节点的个数
    {
        cout << "叶子结点的个数为：";
        size_t count = 0;
        _CountLeft(_pRoot, count);
        cout << count << endl;

        cout << "_CountLeft1：";
        cout << _CountLeft1(_pRoot) << endl;
    }

    void Height()//树的高度
    {
        cout << "树的高度为：";
        cout << _Height1(_pRoot)<< endl;
    }

    void LevelOrder()//层序遍历
    {
        if (_pRoot == NULL)
            return;
        cout << "层次遍历：";
        queue<pNode> s;
        s.push(_pRoot);
        while (!s.empty())
        {
            pNode pCur = s.front();
            cout << pCur->_data << " ";

            if (pCur->_left)
                s.push(pCur->_left);

            if (pCur->_right)
                s.push(pCur->_right);

            s.pop();
        }
        cout << endl;
    }

    void _PreOrder(pNode pRoot)//先序遍历递归实现
    {
        if (pRoot != NULL)
        {
            cout << pRoot->_data << " ";
            _PreOrder(pRoot->_left);
            _PreOrder(pRoot->_right);
        }
    }

    void _PreOrder1(pNode pRoot)//先序遍历非递归实现
    {
        stack<pNode> s;
        pNode pCur = pRoot;
        while (!s.empty()||pCur)
        {
            while (pCur)
            {
                cout << pCur->_data << " ";
                s.push(pCur);
                pCur = pCur->_left;
            }

            //左子树遍历完了
            pNode tmp = s.top();
            s.pop();
            pCur = tmp->_right;
        }
    }

    void _PreOrder2(pNode pRoot)//先序遍历非递归实现
    {
        if (pRoot == NULL)
            return;
        stack<pNode> s;
        s.push(pRoot);
        while (!s.empty())
        {
            pNode pCur = s.top();
            cout << pCur->_data << " ";
            s.pop();

            if (pCur->_right)
                s.push(pCur->_right);
            if (pCur->_left)
                s.push(pCur->_left);
        }
    }

    void _InOrder(pNode pRoot)//中序遍历递归实现
    {
        if (pRoot != NULL)
        {
            _InOrder(pRoot->_left);
            cout << pRoot->_data << " ";
            _InOrder(pRoot->_right);
        }
    }

    void _InOrder1(pNode pRoot)//中序遍历非递归实现
    {
        stack<pNode> s;
        pNode pCur = pRoot;
        while (!s.empty() || pCur)
        {
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->_left;
            }

            //左子树遍历完了
            pNode tmp = s.top();
            cout << tmp->_data << " ";
            s.pop();
            pCur = tmp->_right;
        }
    }

    void _PostOrder(pNode pRoot)//后序遍历递归实现
    {
        if (pRoot != NULL)
        {
            _PostOrder(pRoot->_left);
            _PostOrder(pRoot->_right);
            cout << pRoot->_data << " ";
        }
    }

    void _PostOrder1(pNode pRoot)//后序遍历非递归实现
    {
        stack<pNode> s;
        pNode pCur = pRoot;
        pNode Prev = NULL;
        while (!s.empty() || pCur)
        {
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->_left;
            }
            //左子树遍历完了
            pNode tmp = s.top();
            if (tmp->_right && tmp->_right != Prev)
            {
                pCur = tmp->_right;
            }
            else
            {
                cout << tmp->_data << " ";
                Prev = tmp;
                s.pop();
            }
        }
    }

    void GetKlevelNode(size_t K)//求第K层结点的个数
    {
        cout << "第K层的结点个数是：";

        if (K>_Height1(_pRoot))
            return;

        cout << _GetKlevelNode(_pRoot,K) << endl;
    }

    bool IsNodeInBinTree(pNode pNode)//判断结点是否存在二叉树中
    {
        return _IsNodeInBinTree(_pRoot, pNode);
    }

    pNode Find(const T& data)//查找结点
    {
        return _Find(_pRoot,data);
    }

    void Mirror()//树的镜像
    {
        _Mirror(_pRoot);
    }

    bool IsCompletelyBinTree()//判断树是否为完全二叉树
    {
        return _IsCompletelyBinTree(_pRoot);
    }

protected:

    bool _IsCompletelyBinTree(pNode pRoot)//判断树是否为完全二叉树
    {
        if (pRoot==NULL)
            return true;

        queue<pNode> q;
        q.push(pRoot);
        bool IsFlag = false;
        while (!q.empty())
        {
            pNode tmp = q.front();

            if (IsFlag)
            {
                if (pRoot->_left || pRoot->_right)
                    return false;
            }
            else
            {
                if (tmp->_left&&tmp->_right)
                {
                    q.push(tmp->_left);
                    q.push(tmp->_right);
                }
                else if (tmp->_left)
                {
                    q.push(tmp->_left);
                    IsFlag = true;
                }
                else if (tmp->_right)
                    return false;
                else
                    IsFlag = true;
            }   
            q.pop();
        }
        return true;
    }

    void _Mirror(pNode pRoot)//树的镜像递归实现
    {
        if (pRoot)
        {
            swap(pRoot->_left, pRoot->_right);
            _Mirror(pRoot->_left);
            _Mirror(pRoot->_right);
        }
    }

    void _Mirror1(pNode pRoot)//树的镜像非递归实现
    {
        if (pRoot == NULL)
            return;
        queue<pNode> s;
        s.push(pRoot);
        while (!s.empty())
        {
            pNode tmp = s.front();
            if (tmp->_left || tmp->_right)
                swap(tmp->_left, tmp->_right);

            if (tmp->_left)
                s.push(tmp->_left);

            if (tmp->_right)
                s.push(tmp->_right);

            s.pop();
        }
        cout << endl;
    }

    pNode _Find(pNode pRoot, const T& data)//查找结点
    {
        if (NULL == pRoot)
            return NULL;
        if (pRoot->_data == data)
            return pRoot;

        pNode tmp = _Find(pRoot->_left, data);
        if (tmp)
            return tmp;
        return _Find(pRoot->_right, data);
    }

    bool _IsNodeInBinTree(pNode pRoot, pNode pNode)//判断结点是否存在二叉树中
    {
        if (pRoot == NULL || pNode == NULL)
            return false;

        if (pRoot == pNode)
            return true;

        bool IsIn = _IsNodeInBinTree(pRoot->_left, pNode);
        if (IsIn)
            return true;

        return _IsNodeInBinTree(pRoot->_right, pNode);
    }

    size_t _GetKlevelNode(pNode pRoot,size_t k)//求第K层结点的个数
    {
        if (pRoot == NULL||k==0)
            return 0;
        else if (k == 1)
              return 1;
        else return _GetKlevelNode(pRoot->_left, k - 1) + _GetKlevelNode(pRoot->_right, k - 1);
    }

    size_t _Height(pNode pRoot)//树的高度
    {
        int hl = 0;
        int hr = 0;
        int max = 0;
        if (pRoot)
        {
            hl = _Height(pRoot->_left);
            hr = _Height(pRoot->_right);
            max  = hl > hr ? hl : hr;
            return max+1;
        }
        else
        {
            return 0;
        }
    }

    size_t _Height1(pNode pRoot)//树的高度
    {
        if (pRoot == NULL)
            return 0;
        if (pRoot->_left == NULL&&pRoot->_right == NULL)
            return 1;

        size_t hl = _Height1(pRoot->_left);
        size_t hr = _Height1(pRoot->_right);

        return hl > hr ? ++hl : ++hr;
    }

    size_t _CountNode(pNode pRoot, size_t& count1) //统计结点的个数
    {
        if (pRoot)
        {
            count1++;
            _CountNode(pRoot->_left, count1);
            _CountNode(pRoot->_right, count1);
        }
        return count1;
    }

    size_t _CountNode1(pNode pRoot)  //统计结点的个数
    {
        if (pRoot == NULL)
            return 0;
        else
        {
            return _CountNode1(pRoot->_left) + _CountNode1(pRoot->_right) + 1;
        }
    }

    size_t _CountLeft(pNode pRoot, size_t& count)//叶子结点的个数
    {
        if (pRoot)
        {
            _CountLeft(pRoot->_left, count);
            _CountLeft(pRoot->_right, count);
            if (pRoot->_left == NULL&&pRoot->_right == NULL)
            {
                count++;
            }
        }
        return count;
    }

    size_t _CountLeft1(pNode pRoot)//叶子结点的个数
    {
        if (pRoot == NULL)
            return 0;
        if (pRoot->_left == NULL&&pRoot->_right == NULL)
            return 1;
        return _CountLeft1(pRoot->_left) + _CountLeft1(pRoot->_right);
    }

    void _CreateBinTree(pNode& pRoot, const T* array, size_t size, const T& invalid, size_t& index)//创建二叉树
    {
        if (index < size && array[index] != invalid)
        {
            //创建根节点
            pRoot = new Node(array[index]);

            //创建根节点的左子树
            _CreateBinTree(pRoot->_left, array, size, invalid, ++index);

            //创建根节点的右子树
            _CreateBinTree(pRoot->_right, array, size, invalid, ++index);
        }
    }

    pNode _CopyBinTree(pNode pRoot)//拷贝二叉树
    {
        pNode newRoot = NULL;
        if (pRoot != NULL)
        {
            //拷贝根节点
            newRoot = new Node(pRoot->_data);

            //拷贝根节点左子树
            if (pRoot->_left)
                newRoot->_left = _CopyBinTree(pRoot->_left);

            //拷贝根节点右子树
            if (pRoot->_right)
                newRoot->_right = _CopyBinTree(pRoot->_right);
        }
        return newRoot;
    }

    void _DestoryBinTree(pNode& pRoot)//销毁二叉树
    {
        if (pRoot)
        {
            _DestoryBinTree(pRoot->_left);
            _DestoryBinTree(pRoot->_right);
            delete pRoot;
        }
    }
private:
    pNode _pRoot;
};

test.c文件

#include"BinTree.h"

void TestBinTree()
{
    char* pStr = "ABD###CE##F";
    BinTree<char> bt1(pStr, strlen(pStr), '#');
    BinTree<char> bt2(bt1);
    BinTree<char> bt3;
    bt3 = bt2;
    bt1.PreOrder();
    bt1.InOrder();
    bt1.PostOrder();
    bt1.LeftSize();
    bt1.Size();
    bt1.Height();
    bt1.LevelOrder();
    bt1.GetKlevelNode(3);
    /*bt2.Mirror();
    bt2.PreOrder();
    bt2.Mirror();
    bt2.PreOrder();*/

    /*if (bt1.IsCompletelyBinTree())
        cout << "是完全二叉树"<<endl;
    else
        cout << "不是完全二叉树" << endl;*/
}


int main()
{
    TestBinTree();
    return 0;
}
zl_8577
关注
二叉树的详细实现 (C++)
dielu7895的博客
05-13 2298
二叉树的定义 以递归形式给出的：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根结点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。二又树的特点是每个结点最多有两个子女，分别称为该结点的左子女和右子女。在二又树中不存在度大于2的结点，并且二又树的子树有左、右之分，其子树的次序不能颠倒。二又树是分支数最大不超过2的有根有序树。它可能有5种不同的形态。 ...
【代码】C++实现二叉树基本操作及测试用例
pawnsir的博客
05-28 1586
二叉树是一种常见的数据结构，这里我们需要要注意的是，二叉树的非递归的遍历。    先序遍历，中序遍历，后序遍历    这三种遍历，如果用非递归的方式实现，我们则需要借助栈这个结构，首先我们需要遍历所有左子树的左节点。进行压栈，完成压栈之后，根据不同的需求，判断是否该继续访问或者弹出亦或者是压入该节点的右子树。    层序遍历    不同于其他的遍历方式，层序遍历是以根节点为开始，依次向下，每层从左
C++ 二叉树的实现
weixin_33737134的博客
05-03 89
1 #include&lt;iostream.h&gt; 2 struct tree 3 { 4 int data; 5 tree *left,*right; 6 }; 7 class Btree 8 { 9 static int n; 10 static int m; 11 public: 12 ...
C++树（四）二叉树
最新发布
weixin_70468627的博客
07-25 1880
二叉搜索树（ Binary Search Tree ）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；能够快速查找数据也是二叉搜索树被用于各类数据结构的原因，但这种快速是有限制的，即不会出现退化，假如二叉搜索树退化为链表，则无法做到快速查找数据的要求，所以又出现了平衡二叉树。遍历二叉树的方法可以沿用遍历树的方法——递归。
C++二叉树的实现
ranjiewen的博客
09-20 519
C++实现二叉查找树 啥是二叉查找树 在数据结构中，有一个奇葩的东西，说它奇葩，那是因为它重要，这就是树。而在树中，二叉树又是当中的贵族。二叉树的一个重要应用是它们在查找中的应用，于是就有了二叉查找树。 使二叉树成为一颗二叉查找树，需要满足以下两点： 对于树中的每个节点X，它的左子树中所有项的值都要小于X中的项； 对于树中的每个节点Y，它的右子树中所有项的值都要大于Y中的项。
二叉树的四种遍历方式（前序遍历、中序遍历、后序遍历、测层序遍历）
派拉斯兔子的博客
12-02 7855
二叉树的遍历 遍历是数据结构中的常见的操作，把所有元素都访问一遍。 线性数据结构的遍历比较简单 ①、正序遍历 ②、逆序遍历 根据节点访问顺序的不同，二叉树的常见遍历方式用四种 ①、前序遍历（Preorder Traversal） ②、中序遍历（Inorder Traversal） ③、后序遍历（Postorder Traversal） ④、层序遍历（Level Order Traversal） 前序遍历（Preorder Traversal） 访问顺序 根节点、前序遍历左子树、前序遍历右子
C++实现二叉树基本操作详解
08-28
C++ 实现二叉树基本操作详解 二叉树是一种重要的非线性数据结构，广泛应用于计算机科学和信息技术领域。为了帮助读者更好地理解和掌握二叉树的基本操作，本文将详细介绍 C++ 语言实现二叉树基本操作的方法和技术。 ...
C++自实现二叉树的基本操作
11-03
本文将详细讲解如何使用C++语言实现二叉树的基本操作，包括创建、销毁、插入、删除、查找和遍历，以及反转等操作。 1. **创建算法**： 创建二叉树分为创建空树和非空树。空树的创建只需分配一个空节点，非空树的...
二叉树-基于C++实现的二叉树操作.zip
04-26
接下来，我们可以实现二叉树的基本操作。首先是插入新节点，这通常通过递归完成，先找到合适的位置，然后将新节点插入： ```cpp void insert(Node*& root, int value) { if (root == nullptr) { root = new Node...
C++ 二叉树的基本操作
zhw864680355的博客
03-27 3364
对于一棵二叉树，有三种基本遍历方式： 1、前序遍历（DLR）：先访问根结点，然后遍历左子树，最后遍历右子树。 归结为：从根结点一直从左子树向下直到叶结点，然后返回到叶结点的父亲，再从其父结点的右子树向下。 2、中序遍历（LDR）：先中序遍历左子树，然后访问根结点，最后遍历右子树。 3、后序遍历（LRD）：先后序遍历左子树，然后遍历右子树，最后访问根结点。 对如上图，遍历结果如下： 前...
C++二叉树基本操作
09-29
C++二叉树基本操作
c++二叉树的基本操作
11-25
递归二叉树的基本操作，递归创建，递归先序遍历、中序遍历、后序遍历，求树的高度，求叶子结点的个数，交换树的左右孩子
C++实现二叉树
weixin_34121282的博客
05-11 79
#include <iostream> using namespace std ; class Tree { public : int number ; class Tree *left ; class Tree *right ; void insert_tree(...
二叉树的C++实现
HeHui的专栏
11-25 731
关于二叉树的实现直接贴代码吧： // BinaryTree_Class.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "stdafx.h" #include #include #include using namespace std; template struct _BinNode { T data; struct _B
二叉树的基本操作的c++实现
zelinlee0303的博客
11-23 838
二叉树的算法。    先给出结点的类，顾名思义。是用来表示树的每个结点咯。里面包含char型的data（因为我想是让树的结点值是字母，如果你希望是数字那就int啥的，这个随意吧~） 代码如下：  //Focus.L carpe diem :) //BiTree node.h #ifndef NODE_H_ #define NODE_H_ #define NULL 0 //结点的类 cla
学习c++对二叉树的基本操作（王道数据结构二叉树基本操作）
ytswld的博客
05-18 253
二叉树
C++实现二叉树基本操作：遍历、求树高等
"二叉树的C++实现，包括链式存储结构，基本操作如建立、输出、前序遍历、中序遍历、后序遍历、计算树高及统计叶子节点数量等功能。" 在计算机科学中，二叉树是一种特殊的树结构，其中每个节点最多有两个子节点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值