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

最新推荐文章于 2024-07-25 10:09:27 发布
最新推荐文章于 2024-07-25 10:09:27 发布
阅读量907 收藏 2
点赞数 1
分类专栏： C++ 文章标签： c++ 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tttjp/article/details/75948105
版权

树是一种重要的非线性数据结构，二叉树是树型结构的一种重要类型。本学年论文介绍了二叉树的定义，二叉树的存储结构，二叉树的相关术语，以此引入二叉树这一概念，为展开二叉树的基本操作做好理论铺垫。二叉树的基本操作主要包含以下几个模块：二叉树的遍历方法，计算二叉树的结点个数，计算二叉树的叶子结点个数，二叉树深度的求解等内容。

前序遍历（递归&非递归）

  1. 访问根节点
  2. 前序访问左子树
  3. 前序访问右子树
    //前序非递归
    void PrevOrder()
    {
        stack<Node*> s;
        Node *cur = _root;

        while (cur || !s.empty())
        {
            while (cur)
            {
                cout << cur->_data << " ";
                s.push(cur);
                cur = cur->_left;
            }
            //此时当前节点的左子树已遍历完毕
            Node *tmp = s.top();
            s.pop();
            cur = tmp->_right;
        }
        cout << endl;
    }

    //前序递归
    void PrevOrderR()
    {
        _PrevOrder(_root);

        cout << endl;
    }

    void _PrevOrder(Node *root)
    {
        if (root == NULL) //必须有递归出口！！！
            return;

        cout << root->_data << " ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

中序遍历（递归&非递归）

  1. 中序访问左子树
  2. 访问根节点
  3. 中序访问右子树
    //中序非递归
    void InOrder()
    {
        stack<Node*> s;
        Node *cur = _root;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            //此时当前节点的左子树已遍历完毕
            Node *tmp = s.top();
            cout << tmp->_data << " ";
            s.pop();
            cur = tmp->_right;
        }
        cout << endl;
    }

    //中序递归
    void InOrderR()
    {
        _InOrder(_root);

        cout << endl;
    }

    void _InOrder(Node *root)
    {
        if (root == NULL)
            return;

        _InOrder(root->_left);
        cout << root->_data << " ";
        _InOrder(root->_right);
    }

后序遍历（递归&非递归）

    //后序非递归
    //后序遍历可能会出现死循环，所以要记录下前一个访问的节点
    void PostOrder()
    {
        stack<Node*> s;
        Node *cur = _root;
        Node *prev = NULL;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            Node *tmp = s.top();
            if (tmp->_right && tmp->_right != prev)
            {
                cur = tmp->_right;
            }
            else
            {
                cout << tmp->_data << " ";
                prev = tmp;
                s.pop();
            }
        }
        cout << endl;
    }

    //后序递归
    void PostOrderR()
    {
        _PostOrder(_root);

        cout << endl;
    }

    void _PostOrder(Node *root)
    {
        if (root == NULL)
            return;

        _PostOrder(root->_left);
        _PostOrder(root->_right);
        cout << root->_data << " ";
    }

层序遍历

从根节点开始，依次访问每层结点。
利用队列先进先出的特性，把每层结点从左至右依次放入队列。

    void LevelOrder()  //利用队列！！！
    {
        queue<Node*> q;
        Node *front = NULL;

        //1.push根节点
        if (_root)   
        {
            q.push(_root);
        }
        //2.遍历当前节点，push当前节点的左右孩子，pop当前节点
        //3.遍历当前节点的左孩子，再遍历右孩子，循环直至队列为空
        while (!q.empty())
        { 

            front = q.front();
            cout << front->_data << " ";

            if (front->_left)
                q.push(front->_left);
            if (front->_right)
                q.push(front->_right);

            q.pop();
        }

        cout << endl;
    }

求二叉树的高度

    size_t Depth()
    {
        return _Depth(_root);
    }

    size_t _Depth(Node *root)
    {
        if (root == NULL)
            return 0;
        else if (root->_left == NULL && root->_right == NULL)
            return 1;
        else
        {
            size_t leftDepth = _Depth(root->_left) + 1;
            size_t rightDepth = _Depth(root->_right) + 1;
            return leftDepth > rightDepth ? leftDepth : rightDepth;
        }
    }

求叶子节点的个数

    size_t LeafSize()
    {
        return _LeafSize(_root);
    }

    size_t _LeafSize(Node *root)
    {
        if (root == NULL)
            return 0;
        else if (root->_left == NULL && root->_right == NULL)
            return 1;
        else
            return _LeafSize(root->_left) + _LeafSize(root->_right);
    }

求二叉树第k层的节点个数

    size_t GetKLevel(int k)
    {
        return  _GetKLevel(_root, k);
    }

    size_t _GetKLevel(Node *root, int k)
    {
        if (root == NULL)
            return 0;
        else if (k == 1)
            return 1;
        else
            return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);
    }

完整代码如下：

template<class T>
struct BinaryTreeNode
{
    T _data;
    BinaryTreeNode *_left;
    BinaryTreeNode *_right;

    BinaryTreeNode(const T& d)
        :_data(d)
        , _left(NULL)
        , _right(NULL)
    {}
};

template<class T>
class BinaryTree
{
public:
    typedef  BinaryTreeNode<T> Node;

    BinaryTree()
        :_root(NULL)
    {}

    BinaryTree(T *arr, size_t n, const T& invalid)
    {
        size_t index = 0;
        _root = _CreateBinaryTree(arr, n, invalid, index);
    }

    BinaryTree(const BinaryTree<T>& t)
        :_root(NULL)
    {
        _root = _CopyTree(t._root);
    }

    BinaryTree<T>& operator=(const BinaryTree<T>& t)
    {
        if (this != t)
        {
            Node *tmp = new Node(t._root);
            if (tmp != NULL)
            {
                delete _root;
                _root = tmp;
            }
        }
        return *this;
    }

    ~BinaryTree()
    {
        _DestroyTree(_root);
        cout << endl;
    }

    //前序非递归
    void PrevOrder()
    {
        stack<Node*> s;
        Node *cur = _root;

        while (cur || !s.empty())
        {
            while (cur)
            {
                cout << cur->_data << " ";
                s.push(cur);
                cur = cur->_left;
            }
            //此时当前节点的左子树已遍历完毕
            Node *tmp = s.top();
            s.pop();
            cur = tmp->_right;
        }
        cout << endl;
    }

    //前序递归
    void PrevOrderR()
    {
        _PrevOrder(_root);

        cout << endl;
    }

    //中序非递归
    void InOrder()
    {
        stack<Node*> s;
        Node *cur = _root;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            //此时当前节点的左子树已遍历完毕
            Node *tmp = s.top();
            cout << tmp->_data << " ";
            s.pop();
            cur = tmp->_right;
        }
        cout << endl;
    }

    //中序递归
    void InOrderR()
    {
        _InOrder(_root);

        cout << endl;
    }

    //后序非递归
    //后序遍历可能会出现死循环，所以要记录下前一个访问的节点
    void PostOrder()
    {
        stack<Node*> s;
        Node *cur = _root;
        Node *prev = NULL;

        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            Node *tmp = s.top();
            if (tmp->_right && tmp->_right != prev)
            {
                cur = tmp->_right;
            }
            else
            {
                cout << tmp->_data << " ";
                prev = tmp;
                s.pop();
            }
        }
        cout << endl;
    }

    //后序递归
    void PostOrderR()
    {
        _PostOrder(_root);

        cout << endl;
    }

    void LevelOrder()  //利用队列！！！
    {
        queue<Node*> q;
        Node *front = NULL;

        //1.push根节点
        if (_root)   
        {
            q.push(_root);
        }
        //2.遍历当前节点，push当前节点的左右孩子，pop当前节点
        //3.遍历当前节点的左孩子，再遍历右孩子，循环直至队列为空
        while (!q.empty())
        { 

            front = q.front();
            cout << front->_data << " ";

            if (front->_left)
                q.push(front->_left);
            if (front->_right)
                q.push(front->_right);

            q.pop();
        }

        cout << endl;
    }

    size_t Size()
    {
        return _Size(_root);
    }

    size_t LeafSize()
    {
        return _LeafSize(_root);
    }

    size_t GetKLevel(int k)
    {
        return  _GetKLevel(_root, k);
    }

    size_t Depth()
    {
        return _Depth(_root);
    }

    Node* Find(const T& d)
    {
        return _Find(_root, d);
    }

protected:
    Node* _CreateBinaryTree(T *arr, size_t n, const T& invalid, size_t& index)
    {
        Node *root = NULL;
        if (index < n && arr[index] != invalid)
        {
            root = new Node(arr[index]);
            index++;
            root->_left = _CreateBinaryTree(arr, n, invalid, index);
            index++;
            root->_right = _CreateBinaryTree(arr, n, invalid, index);
        }
        return root;
    }

    Node* _CopyTree(Node *root)
    {
        Node *newRoot = NULL;

        if (root)
        {
            newRoot = new Node(root->_data);
            newRoot->_left = _CopyTree(root->_left);
            newRoot->_right = _CopyTree(root->_right);
        }

        return newRoot;
    }

    void _DestroyTree(Node *root)
    {
        if (root)
        {
            _Destroy(root->_left);
            _Destroy(root->_right);
            delete root;
        }
    }

    void _PrevOrder(Node *root)
    {
        if (root == NULL) //必须有递归出口！！！
            return;

        cout << root->_data << " ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

    void _InOrder(Node *root)
    {
        if (root == NULL)
            return;

        _InOrder(root->_left);
        cout << root->_data << " ";
        _InOrder(root->_right);
    }

    void _PostOrder(Node *root)
    {
        if (root == NULL)
            return;

        _PostOrder(root->_left);
        _PostOrder(root->_right);
        cout << root->_data << " ";
    }

    size_t _Size(Node *root)
    {
        if (root == NULL)
            return 0;
        else
            return _Size(root->_left) + _Size(root->_right) + 1;
    }

    size_t _LeafSize(Node *root)
    {
        if (root == NULL)
            return 0;
        else if (root->_left == NULL && root->_right == NULL)
            return 1;
        else
            return _LeafSize(root->_left) + _LeafSize(root->_right);
    }

    size_t _GetKLevel(Node *root, int k)
    {
        if (root == NULL)
            return 0;
        else if (k == 1)
            return 1;
        else
            return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);
    }

    size_t _Depth(Node *root)
    {
        if (root == NULL)
            return 0;
        else if (root->_left == NULL && root->_right == NULL)
            return 1;
        else
        {
            size_t leftDepth = _Depth(root->_left) + 1;
            size_t rightDepth = _Depth(root->_right) + 1;
            return leftDepth > rightDepth ? leftDepth : rightDepth;
        }
    }

    Node* _Find(Node *root, const T& d)
    {
        if (root == NULL)
            return NULL;
        else if (root->_data == d)
            return root;
        else if (Node *ret = _Find(root->_left, d))
            return ret;
        else
            _Find(root->_right, d);
    }

protected:
    Node *_root;
};
tttjp
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现二叉树
qq_45285738的博客
03-10 876
接下来，你将看到，输出先序、层序遍历结果等内容，如下：（注：中序后序，操作类似于前序遍历，没有实现）1.2 实现二叉树的访问 --- 先中后序访问、层序访问。1.3 计算树的深度、节点数、复制树。2.1 首先创建出一棵二叉树。1.1 实现二叉树的创建。
二叉树的基本操作(C++实现)
qq_52109814的博客
08-09 2万+
基本概念 二叉树由结点的有限集合构成。 这个有限集合要么是空集，要么是一个根节点及两棵互不相交、分别称为这个跟的左子树和右子树的二叉树组成的集合。 二叉树的特点 每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。 左子树和右子树是有顺序的，次序不能随意颠倒。 及时树中某结点只有一颗子树，也要区分它是左子树还是右子树。 二叉树的五种基本形态 空二叉树 只有一个根节点 根节点只有左子树 根节点只有右子树 根节点既有左子树，又有右子树 相关概念 边（edge）：两个结点（node）的有序对（ord
C C++最新《数据结构C语言版》——二叉树详解(图文并茂)_c语言二叉树，你掌握了多少
2401_84976733的博客
05-15 890
光有图还不够严谨，二叉树的定义是这样的二叉树(Binary Tree)：是n(n≥0)个结点的有限集合，该集合或者为空集(称为空二叉树)，或者由一个根结点和两颗互不相交的、分别称为根结点的左子树和右子树的二叉树组成。本身是有序树；树中包含的各个结点的度不能超过 2，即只能是 0、1 或者 2；如图所示，a的度最多是2，所以是二叉树，而b有度为3的结点，所以不是二叉树！
C++模板实现二叉树基本操作
starzyh的博客
05-16 958
#ifndef BINARYTREE_H #define BINARYTREE_H #include <iostream> #include <stack> #include <queue> using namespace std; template <typename T> struct btNode { T _data; s...
二叉树基本操作C++实现
Charming的博客
10-14 1008
二叉树基本操作C++实现 基本操作预览: 先序遍历: element:1 element:2 element:3 中序遍历: element:2 element:1 element:3 二叉树的结点个数： 3 度为2的结点个数: 1 度为1的结点个数: 0 叶子结点个数: 2 二叉树的高度: 2 是不是完全二叉树(1-是;0-不是): 1 #include <stdio.h> #include <iostream> using namespace std; typedef st
二叉树的基本操作（C++实现）
锦恢的博客
11-21 2972
文章目录前言创建二叉树展示二叉树销毁二叉树判断是否为完全二叉树计算树的高度计算树的叶子数量计算树的宽度层次遍历前序遍历递归写法非递归写法中序遍历递归写法非递归写法后序遍历递归写法非递归写法输出根节点到所有叶子节点的路径(递归)输出根节点到所有叶子节点的路径(非递归)计算二叉树的公共祖先(lca)递归写法非递归写法验证 前言 二叉树可以说是树形数据结构中最基础的，且在多种领域都有应用（比如语法树，二值决策树），熟悉其各种操作是必须的。本文通过实现几个基本的函数来实现一个基本的二叉树： #include &lt
C++实现二叉树的构建和基本操作
m0_62551907的博客
05-25 986
#include <iostream> using namespace std; typedef struct BiNode { int data; //本次采用整数 struct BiNode* lchild, * rchild; //左孩子 右孩子 } BiNode, * BiTree; //先序遍历 void Xianxu(BiTree T) { if (T) { cout << T->data; Xianxu(T->lchild); X.
二叉树的基本操作
热门推荐
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
C++ 二叉树的基本操作
zhw864680355的博客
03-27 3345
对于一棵二叉树，有三种基本遍历方式： 1、前序遍历（DLR）：先访问根结点，然后遍历左子树，最后遍历右子树。 归结为：从根结点一直从左子树向下直到叶结点，然后返回到叶结点的父亲，再从其父结点的右子树向下。 2、中序遍历（LDR）：先中序遍历左子树，然后访问根结点，最后遍历右子树。 3、后序遍历（LRD）：先后序遍历左子树，然后遍历右子树，最后访问根结点。 对如上图，遍历结果如下： 前...
【代码】C++实现二叉树基本操作及测试用例
pawnsir的博客
05-28 1578
二叉树是一种常见的数据结构，这里我们需要要注意的是，二叉树的非递归的遍历。    先序遍历，中序遍历，后序遍历    这三种遍历，如果用非递归的方式实现，我们则需要借助栈这个结构，首先我们需要遍历所有左子树的左节点。进行压栈，完成压栈之后，根据不同的需求，判断是否该继续访问或者弹出亦或者是压入该节点的右子树。    层序遍历    不同于其他的遍历方式，层序遍历是以根节点为开始，依次向下，每层从左
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++实现二叉树的基本功能
11-05
以上就是用C++实现二叉树基本功能的核心内容。通过这些方法，你可以创建、操作和分析二叉树，进一步理解和应用这种数据结构。在实际编程中，还可以根据需求扩展这些功能，如插入、删除节点，判断平衡等。
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 393
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》
最新发布
buyaotutou的博客
07-25 1134
例如：第一章 Python 机器学习入门之pandas的使用文章链接Multimodal Emotion Recognition is an important research area for developing human-centric applications, especially in the context of video platforms. Most existing models have attempted to develop sophisticated fusion tech
背单词工具(C++)
zeyeqianli的博客
07-24 3312
【代码】背单词工具(C++)
C++ //练习 15.28 定义一个存放Quote对象的vector，将Bulk_quote对象传入其中。计算vector中所有元素总的net_price。
Made in Code
07-25 613
C++ Primer（第5版） 练习 15.28
C++实现二叉树遍历及其应用详解
它涵盖了五个主要章节，分别是树的基本概念、二叉树的定义与存储表示、二叉树的遍历方法及其应用、树与森林以及堆和Huffman树的应用。 在第5章的二叉树部分，首先介绍了二叉树的定义，强调了遍历的含义，即按特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值