二叉树干货----真的很重要

最新推荐文章于 2025-03-07 08:00:00 发布
最新推荐文章于 2025-03-07 08:00:00 发布
阅读量769 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 二叉树 遍历 递归 结构 struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ValDC_Morning/article/details/72712646
本文介绍了二叉树的基本概念及遍历方法，包括前序、中序、后序和层序遍历，并提供了递归与非递归实现代码。同时，文章探讨了二叉树的创建、复制构造、赋值运算符重载等操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 一：相关概念
 二叉树是最基本的树形结构，遍历二叉树就是通过特定的顺序遍历二叉树的每一个节点。
 二叉树遍历方法，前序遍历，中序遍历，后序遍历，层序遍历，前三种遍历又有递归遍历方法和非递归遍历方法。

 二：代码实现
 1.创建树

template<class T>
struct BinaryTreeNode//树的节点信息
{
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;
    T _data;
    BinaryTreeNode(const T& x)
        :_left(NULL),
        _right(NULL),
        _data(x)
    {}
};

BinaryTree()//构造函数
        :_root(NULL)
    {}

    BinaryTree(T* a, size_t n, const T& invalid)//创建树
    {
        size_t index = 0;
        _root = CreateTree(a, n, invalid, index);
    }

    Node* CreateTree(T* a, size_t n, const T& invalid, size_t& index)
//树的创建  利用递归函数
    {
        Node* root = NULL;

        if (index < n && a[index] != invalid)
        {
            root = new Node(a[index]);
            root->_left = CreateTree(a, n, invalid, ++index);
            root->_right = CreateTree(a, n, invalid, ++index);
        }
        return root;
    }
 2.还有拷贝构造、赋值运算符重载、析构函数
 赋值运算符重载有两种方式，传统写法和现代写法，现代写法直接用swap函数交换两节点内容，先拷贝构造再调用析构函数。
  3.项目整体代码如下：

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

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

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

};

template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        :_root(NULL)
    {}

    BinaryTree(T* a, size_t n, const T& invalid)
    {
        size_t index = 0;
        _root = CreateTree(a, n, invalid, index);
    }
    BinaryTree(const BinaryTree<T>& t)//拷贝构造二叉树
    {
        _root = _Copy(t._root);
    }
    //BinaryTree<T>& operator=(const BinaryTree<T>& t)//赋值运算符重载
    //{
    //  if (this != &t)
    //  {
    //      Destroy(_root);
    //      _root = _Copy(t._root);
    //  }
    //  return *this;
    //}
    BinaryTree<T>& operator=(BinaryTree<T> t)
    {
        swap(_root, t._root);//先拷贝构造再调用析构函数
        return *this;
    }

    size_t Size()//求二叉树叶子节点的个数
    {
        return _Size(_root);
    }

    void PrevOrder()//前序遍历递归法
    {
        _PrevOrder(_root);
        cout << endl;
    }

    void LevelOrder()//层序遍历
    {
        queue<Node*> q;
        if (_root)
        {
            q.push(_root);
            while (!q.empty())
            {
                Node* front = q.front();
                cout << front->_data << " ";
                if (front->_left)
                {
                    q.push(front->_left);
                }
                if (front->_right)
                {
                    q.push(front->_right);
                }
                q.pop();
            }
            cout << endl;
        }
    }

    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

    void PostOrder()
    {
        _PostOrder(_root);
        cout << endl;
    }

    size_t LeafSize()//叶节点数目
    {
        return _LeafSize(_root);
    }

    Node* Find(const T& x)//在二叉树中找一个数
    {
        return _Find(_root, x);
    }

    void PrevOrderNoR()//前序遍历非递归
    {
        if (NULL == _root)
        {
            return;
        }
        stack<Node*> s;
        Node* cur = _root;
        while (cur || !s.empty())//当前节点不为空或栈不为空
        {
            while (cur)
            {
                cout << cur->_data << " ";
                s.push(cur);
                cur = cur->_left;
            }
            Node* top = s.top();
            s.pop();
            cur = top->_right;
        }
        cout << endl;
    }

    void InOrderNoR()//中序非递归  利用栈实现
    {
        if (NULL == _root)
        {
            return;
        }
        stack<Node*> s;
        Node* cur = _root;
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            Node* top = s.top();
            s.pop();
            cout << top->_data<<" ";
            cur = top->_right;
        }
        cout << endl;
    }

    size_t Depth()//二叉树深度
    {
        return _Depth(_root);
    }

    size_t GetKLevel(size_t k)//第K层叶子节点个数
    {
        return _GetKLevel(_root, k);     
    }

    void PostOrderNoR()//后序非递归
    {
        if (NULL == _root)
        {
            return;
        }
        Node* cur = _root;
        stack<Node*> s;
        Node* prev = NULL;//保存最近访问过的一个节点
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            Node* top = s.top();

            if (top->_right == NULL || top->_right == prev)
            {
                cout << top->_data << " ";
                prev = top;
                s.pop();
            }
            else
            {
                cur = top->_right;
            }

        }
    }

    ~BinaryTree()//析构函数
    {
        Destroy(_root);
    }

protected:
    Node* CreateTree(T* a, size_t n, const T& invalid, size_t& index)
    {
        Node* root = NULL;

        if (index < n && a[index] != invalid)
        {
            root = new Node(a[index]);
            root->_left = CreateTree(a, n, invalid, ++index);
            root->_right = CreateTree(a, n, invalid, ++index);
        }
        return root;
    }

    Node* _Copy(Node* root)
    {
        if (root == NULL)
        {
            return NULL;
        }
        Node* newRoot = new Node(root->_data);
        newRoot->_left = _Copy(root->_left);
        newRoot->_right = _Copy(root->_right);
        return newRoot;
    }

    Node* _PrevOrder(Node* root)
    {
        if (root == NULL)
        {
            return NULL;
        }
        else
        {
            cout << root->_data << " ";
            _PrevOrder(root->_left);
            _PrevOrder(root->_right);
        }
        return root;
    }

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

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

    Node* _InOrder(Node* root)
    {
        if (root == NULL)
        {
            return NULL;
        }
        else
        {
            _InOrder(root->_left);
            cout << root->_data << " ";
            _InOrder(root->_right);
        }
        return root;
    }

    Node* _PostOrder(Node* root)
    {
        if (root == NULL)
        {
            return NULL;
        }
        else
        {
            _PostOrder(root->_left);
            _PostOrder(root->_right);
            cout << root->_data << " ";
        }
        return root;
    }

    size_t _GetKLevel(Node* root, size_t k)//第k层节点个数
    {
        assert(k > 0);
        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 _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 _Size(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        if (root->_left == NULL&&root->_right == NULL)
        {
            return 1;
        }
        else
        {
            return _Size(root->_left) + _Size(root->_right) + 1;
        }
    }

    void Destroy(Node *root)//删除节点
    {
        if (root == NULL)
        {
            return;
        }
        Destroy(root->_left);
        Destroy(root->_right);
        delete root;
    }
    Node* _root;
};

4.测试用例

#pragma once

#include "BinaryTree.h"

void TestBinaryTree()
{
    int arr[12] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 ,7,8};
    BinaryTree<int> t1(arr, sizeof(arr) / sizeof(arr[0]), '#');
    cout << "前序遍历:" << " ";
    t1.PrevOrder();//前序遍历
    cout << endl;
    cout << "层序遍历:" << " ";
    t1.LevelOrder();//层序遍历
    cout << endl;
    cout << "中序遍历:" << " ";
    t1.InOrder();//中序遍历
    cout << endl;
    cout << "后序遍历:" << " ";
    t1.PostOrder();//后序遍历
    cout << endl;
    cout << "前序遍历递归法:" << " ";
    t1.PrevOrderNoR();
    cout << endl;
    cout << "中序遍历递归法:" << " ";
    t1.InOrderNoR();
    cout << t1.LeafSize() << endl;;
    cout << t1.GetKLevel(1) << endl;
    cout << t1.GetKLevel(2) << endl;
    cout << t1.GetKLevel(3) << endl;
    cout << t1.GetKLevel(13) << endl;

    cout << t1.Find(4) << endl;
    cout<<t1.Find(10)<<endl;
    cout << t1.Depth() << endl;
    cout << t1.Size() << endl;
    t1.PostOrder();
    t1.PostOrderNoR();
    cout << endl;
    t1.PrevOrderNoR();
    t1.PrevOrder();
    cout << t1.Size() << endl;
    BinaryTree<int>t2(t1);
    t2 = t1;
    t2.PrevOrder();
    t2.PostOrder();
    t2.PostOrderNoR();

}

int main()
{
    Te
stBinaryTree();
    system("pause");
    return 0;
}

       当然这个测试用例还不是很全面，完整测试用例需要把每种情况都测试一遍，遍历二叉树还有线索化二叉树，可以利用将其线索化然后利用线索对其进行遍历。

二叉搜索树的遍历、插入新节点val及判断是否存在val(代码及注释)
weixin_45699237的博客
03-17 610
源代码 代码展示： package bin_tree.seachtree; /** * 基于整形的普通二分搜索树 * @author wyc * @date 2022/03/16 18:20 **/ public class BST { private class TreeNode { private int val; private TreeNode left; private TreeNode right; pub.
【数据结构】01_二叉树到底是个什么玩意儿?
达康书记写代码
05-27 516
【数据结构】01_二叉树到底是个什么玩意儿?定义操作原理合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 定义 在计算机科学中，二叉树（英语：Binary tree）是每个节点最多只有两个分支（即不存在分支度大于2的节点）的树结 构。通常
二叉树（重要）
c梦的博客
10-20 384
二叉树的概念 树有很多种，而二叉树就是每个节点的度最多为2的树。说通俗一点，就是每个节点最多最多只能有两个子节点的树。 图1：图中的三棵树都是二叉树 图2：图中这棵树就不是二叉树，因为有节点的度为3，大于了2 二叉树的特点 每个节点最多有两棵子树，所以二叉树中不存在度大于2的节点。 子节点有左右之分，左子节点衍生的树是左子树，右子节点衍生的树叫右子树。 左子树和右子树是有顺序的，次序不...
二叉树（binary tree）-重要性
zhanghongxian123的专栏
01-18 2901
二叉树是一种最简单、最基础、最重要的树结构。它能： 支持强大的搜索算法； 链式结构按照需要分配内存； 有规则的存储对象； ….能想到的讨论集中在搜索和存储方面；它同时是一种数据结构，或数据类型，或容器，面向对象的方式思考的话，作为一个类。二叉树存储元素涉及2个普遍的，所有容器都涉及的操作：增加和删除；二叉树之所以重要，是因为它支持或拥有的操作，包括增删改查重要的操作，复杂度比完成同样功能的其
二叉树的一个重要性质
大无赖blog
05-16 473
对于一个二叉树，如果其终端结点数位n0，度为2的结点数为n2，则n0=n2+1。 证明：设n1为二叉树T中度为1的结点数。因为二叉树所有结点的度均小于或等于2，所以其结点总数为n=n0+n1+n2。 再看二叉树的分支数。除了根节点，其余结点都有一个分支进入，设B为分支总数，则n=B+1。由于分支是由度为1或2的结点射出的，所以又有B=n1+n2。于是又得n=n1+2n2+1。 最终可得n0=
C语言二叉树主要干嘛,C语言二叉树基本功能.doc
weixin_34532234的博客
05-21 166
#include #define OK 1#define ERROR 0#define MAXSIZE 50 /*定义队列的最大长度*/typedef char ElemType;/*******************************定义二叉链表结构***********************...
二叉树是一种特殊的树状结构，其中每个节点最多只能有两个子节点，通常被称为左子节点和右子节点
BLOG域名:programb.blog.youkuaiyun.com
03-01 2158
度为2的树不区分子树的次序，而二叉树中的每个结点最多有两个孩子结点，且必须要区分左右子树，即使在结点只有一棵子树的情况下也要明确指出该子树是左子树还是右子树。由二叉树的性质4可知，对于完全二叉树和满二叉树，树中结点层序编号可以唯一地反映出结点之间的逻辑关系，所以可以用一维数组按从上到下、从左到右的顺序存储树中所有结点值，通过数组元素的下标关系反映完全二叉树或满二叉树中结点之间的逻辑关系。深入理解和掌握二叉树的结构和性质，有助于在这些领域中进行有效的数据表示、存储、检索和操作，实现高效的数据处理和分析。
二叉树的用途-（未完）
热门推荐
LearnLHC的博客
03-01 1万+
二叉树 二叉树是一种重要的数据结构，与数组、向量、链表都是一种顺序容器，它们提供了按位置访问数据的手段。但是有一个缺点，它们都是按照位置来确定数据，想要通过值来获取数据，只能通过遍历的方式。而二叉树在很大程度上解决了这个缺点，二叉树是按值来保存元素，也按值来访问元素。 二叉树由一个个节点组成，一个节点最多只能有两个子节点，从根节点开始左右扩散，分左子节点和右子节点，向下一直分支。 许多实际问...
二叉树是数据结构中非常重要的一部分，下面我们来说如何学好二叉数。
bkf136114378的博客
05-25 347
1树的概念 （1）树是一种非线性的数据结构，它是由n（N>=0）个有限节点组成的一个具有层次关系的结合。 （2）边：从父节点到子节点的连线（边有方向） （3）兄弟节点：父节点相同的节点互为兄弟节点（如上图中的2 3，4 5， 6 7等都是兄弟节点）。 （4）树叶、分支节点：没有子节点的节点称为树叶，树中的其余节点称为分支节点，分支节点可只有一个分支，（12 9 10 11 7都是叶节点）。 ...
查找--平衡二叉树（VAL树）
weixin_44315921的博客
01-18 1262
右旋 //P为根节点；L为左子树根节点； void R_rotate(TreeNode P) { TreeNode L=P.left;//L是旋转后新的根节点，最终L的右子树指向原节点P； P.left=L.right;//L的原右子树作为P的左子树 L.right=P;//L的右子树指向原节点P； P=L;//P指向新的根节点。 } ...
【全面解析！】二叉树及其应用
m0_64799333的博客
03-06 2588
1.在用树表示的目录结构中，从根目录到任何数据文件只有唯一一条通道，因为树的特点是不相交2.3.（1）根据中序遍历和后序遍历顺序构建二叉树（2）根据前序遍历和中序遍历顺序构建二叉树Q1：为什么后序+中序构建二叉树是先root.left再root.right;而前序+中序构建二叉树是先root.right再root.left?A1:根据上面的图片我们可以看到，根据后序遍历的顺序，我们先在中序中找到根节点，下一步找到的是右树，所以我们在写代码的时候要先写root，再right，最后left；
二叉树及其作用浅析
猫哥 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS，AIOT)
10-14 1万+
在学习数据结构和算法时看到各种树，把人都整蒙了，枯燥且提不起学习兴趣。等逐渐感受到二叉树的神奇作用和巨大的应用价值后，觉得二叉树原来也这么有趣，值得好好学习。 先从整体上认识下二叉树及其他各种树的区别和用途。 大致有哪些树？ 树有很多种，其中二拆树因为其特殊的结构和特点在计算上最为常用。 常见的二叉树：二叉查找树，平衡二叉树(AVL)，红黑树，B+树，B-树，字典树，满二叉树，完全二叉树，霍夫曼树，伸展树，最小堆，最大堆等。 二叉树有什么用？ 二叉树应用非常广泛。 在操作系统源程序中，树和.
二叉树概念与使用
全栈开发的博客
08-13 1344
例如，在二叉搜索树（Binary Search Tree, BST）中，数据以中序遍历的方式（左-根-右）有序排列，使得查找、插入和删除操作都可以在对数时间复杂度内完成，这比线性表（如数组或链表）的效率要高得多。的二叉树的最大节点数”时，我们实际上是在考虑一个完全二叉树（Complete Binary Tree），这种树在每一层都尽可能多地填充节点，直到达到指定的深度。的二叉树（这里我们假设根节点的深度为1，这是另一种常见的约定，尽管有时也将根节点的深度视为0），其最大节点数可以通过分析树的结构来得出。
深入剖析二叉树：从基础到高级应用
最新发布
阿新的博客
03-07 984
二叉树是一种每个节点最多只能有两个子节点的树结构。二叉树的子节点分为左节点和右节点，这种结构使得二叉树在数据存储和检索中具有高效性。本文是二叉树系列文章的第一篇，旨在深入探讨二叉树的基本概念、存储方式、遍历方法以及查找与删除操作。后续文章将陆续介绍二叉排序树、红黑树、平衡二叉树、顺序存储二叉树以及其他树结构，帮助读者全面掌握树结构的核心知识。
二叉树的5个重要性质
qq_44761480的博客
08-15 270
原文：https://blog.youkuaiyun.com/tianlihua306/article/details/44621827 1.在二叉树的第i层上最多有2i−12^{i-1}2i−1 个节点 。（i>=1） 用归纳法证明： 归纳基：i = 1 层时，只有一个根结点， 2i−1=20=1；2^{i-1} = 2^0 = 1；2i−1=20=1； 归纳假设：假设i=k时，命题成立; 归纳证明：...
数据结构之二叉树
m0_62734392的博客
01-07 234
手撕数据结构与算法~~二叉树篇,讲解了二叉树的概念还有用Java代码去实现二叉树
二叉树的所有左（右）叶子的val的和
天上有好多星星
03-02 296
来自LeetCode----->404 解决的方法如下： 核心思路--------父亲的右孩子不为当前叶子本身，即为我们需要的叶子（首先筛选出叶子结点） 叶子----->Node.left == null && Node.right == null /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * T
数据结构--二叉树的概念及遍历方法
qq_60338902的博客
05-25 657
二叉树 一 . 概念 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉 树组成。 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。 二 . 二叉树的性质 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 (i>0)个结点 若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 (k>=0) 对任何一棵二叉树, 如果其叶
【数据结构1-2】二叉树
Sebastian_Nova的博客
01-26 1009
树形结构不仅能表示数据间的指向关系，还能表示出数据的层次关系，而有很明显的递归性质。因此，我们可以利用树的性质解决更多种类的问题。但是在平常的使用中，我们并不需要使用这么复杂的结构，只需要建立一个包含int right和int left的结构体即可，left和right用于指示该节点的左儿子和右儿子。
Objective-C实现的完全二叉树优先队列教程
资源摘要信息:"二叉树-基于Objective-C的完全二叉树实现的优先队列" 知识点概述: 1. Objective-C编程语言基础 2. 二叉树数据结构概念 3. 完全二叉树定义与特性 4. 优先队列原理与实现 5. Objective-C在二叉树及优先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值