数据结构中二叉树实现及部分操作

最新推荐文章于 2025-06-07 00:48:44 发布
最新推荐文章于 2025-06-07 00:48:44 发布
阅读量5k 收藏 15
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34021920/article/details/78698930
本文详细介绍了树和二叉树的基本概念，包括节点、根节点、度等，并深入探讨了二叉树的特性及其实现方法。文章还提供了二叉树的C++代码示例，包括递归和非递归的遍历方法。

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

谈二叉树之前，我们先来看看树的定义

树：由N(N>=0)个结点构成的集合。
对N>1的树：
1、有一个特殊的结点，称为根结点，根节点没有前驱结点
2、除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。
因此，树是递归定义的。
如下图所示：
这里写图片描述

再看一些和树有关的概念：

  • 节点：节点包含数据和指向其它节点的指针。
  • 根节点：树第一个结点称为根节点。
  • 节点的度：节点所拥有的子树的个数。
  • 树的度：树中所有节点的度的最大值称为该树的度。
  • 叶子节点：没有子节点的节点(度为0)，也称为终端节点。
  • 父子节点：一个节点father指向另一个节点child，则child为孩子节点，father为父亲节点 。
  • 兄弟节点：具有相同父节点的节点互为兄弟节点。
  • 祖先节点：从根节点开始到该节点所经的所有节点都可以称为该节点的祖先。
  • 子孙节点：以某节点为根的子树中任一节点都称为该节点的子孙。
  • 树的高度：树中距离根节点最远节点的路径长度。

树中比较特殊的就是二叉树了，来看看二叉树的定义
二叉树：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树的二叉树组成。

二叉树的特点：
  • 每个结点最多有两棵子树，即二叉树不存在度大于2的结点(分支数最大不超过2)
  • 二叉树的子树有左右之分，其子树的次序不能颠倒

看张二叉树的示意图：
这里写图片描述
二叉树就是由上面这五种情况嵌套或组合而成

在介绍两种比较特殊的二叉树

1.完全二叉树

如果一棵具有N个结点的二叉树的结构与满二叉树的前N个结点的结构相同，称为完全二叉树。

这里写图片描述

2.满二叉树

在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子节点都在同一层上。

这里写图片描述

从概念和图我们可以看出：满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树。

接下来就是二叉树的具体实现了，直接上代码：

BinaryTree.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once

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

//二叉树节点
template <class T>
struct BinaryTreeNode
{
    BinaryTreeNode(const T& data)
    :_pLeft(NULL)
    , _pRight(NULL)
    , _data(data)
    {}

    BinaryTreeNode<T>* _pLeft;//左子树
    BinaryTreeNode<T>* _pRight;//右子树
    T _data;//数据
};

//二叉树
template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T>* pNode;
    typedef BinaryTreeNode<T> Node;
public:
    //无参构造函数
    BinaryTree()
        : _pRoot(NULL)
    {}
    //带参数的构造函数
    BinaryTree(T* arr, size_t size, const T& invalid)
    {
        size_t index = 0;
        _CreateBinaryTree(_pRoot, arr, size, index, invalid);
    }
    //拷贝构造函数
    BinaryTree(const BinaryTree<T>& bt)
    {
        _pRoot = _CopyBinaryTree(bt._pRoot);
    }
    //赋值运算符重载(两种方式均可)
    //BinaryTree& operator=(const BinaryTree<T>& bt)
    //{
    //  if (this != &bt)
    //  {
    //      _DestoryBinaryTree(_pRoot);
    //      _pRoot = _CopyBinaryTree(bt._pRoot);
    //  }
    //  return *this;
    //}
    BinaryTree& operator=(const BinaryTree<T>& bt)
    {
        swap(_pRoot, bt._pRoot);
        return *this;
    }
    //析构函数
    ~BinaryTree()
    {
        _DestoryBinaryTree(_pRoot);
    }
    //递归前序遍历
    void PreOrder()
    {
        _PreOrder(_pRoot);
        cout << endl;
    }
    //递归中序遍历
    void InOrder()
    {
        _InOrder(_pRoot);
        cout << endl;
    }
    //递归后序遍历
    void PostOrder()
    {
        _PostOrder(_pRoot);
        cout << endl;
    }
    //层序遍历(用队列)
    void LevelOrder()
    {
        queue<pNode> q;
        if (_pRoot)
            q.push(_pRoot);
        while (!q.empty())
        {
            pNode cur = q.front();
            q.pop();
            cout << cur->_data << " ";
            if (cur->_pLeft)
            {
                q.push(cur->_pLeft);
            }
            if (cur->_pRight)
            {
                q.push(cur->_pRight);
            }
        }
        cout << endl;
    }
    //非递归前序遍历
    void PreOrderNoR()
    {
        _PreOrderNoR2(_pRoot);
    }
    //非递归中序遍历
    void InOrderNoR()
    {
        _InOrderNoR(_pRoot);
    }
    //非递归后序遍历
    void PostOrderNoR()
    {
        _PostOrderNoR(_pRoot);
    }
    //二叉树节点个数
    size_t Size()
    {
        return _Size(_pRoot);
    }
    //二叉树叶子节点个数
    size_t LeafSize()
    {
        return _LeafSize(_pRoot);
    }
    //二叉树第K层节点个数
    size_t KSize(size_t k)
    {
        return _KSize(_pRoot, k);
    }
    //二叉树高度
    size_t Height()
    {
        return _Height(_pRoot);
    }
    //寻找二叉树中的节点
    pNode Find(const T& data)
    {
        return _Find(_pRoot, data);
    }
    //寻找某节点的双亲节点
    pNode FindParent(pNode node)
    {
        return _FindParent(_pRoot, node);
    }
    //寻找某节点的左孩子节点
    pNode FindLeftChild(pNode node)
    {
        return _FindLeftChild(_pRoot, node);
    }
    //寻找某节点的右孩子节点
    pNode FindRightChild(pNode node)
    {
        return _FindRightChild(_pRoot, node);
    }

//封装函数
private:
    //创建二叉树(前序遍历)
    void _CreateBinaryTree(pNode& pRoot, T* arr, size_t size, size_t& index, const T& invalid)
    {
        if (index < size&&invalid != arr[index])
        {
            pNode pNewNode = new Node(arr[index]);
            _CreateBinaryTree(pNewNode->_pLeft, arr, size, ++index, invalid);
            _CreateBinaryTree(pNewNode->_pRight, arr, size, ++index, invalid);
            pRoot = pNewNode;
        }
    }
    //拷贝二叉树
    pNode _CopyBinaryTree(pNode pRoot)
    {
        if (pRoot == NULL);
        {
            return NULL;
        }
        pNode tmp = new Node(pRoot->_data);
        tmp->_pLeft = _CopyBinaryTree(pRoot->_pLeft);
        tmp->_pRight = _CopyBinaryTree(pRoot->_pRight);
        return tmp;
    }
    //递归前序遍历
    void _PreOrder(pNode pRoot)
    {
        if (pRoot)
        {
            cout << pRoot->_data << " ";
            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }
    //递归中序遍历
    void _InOrder(pNode pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout << pRoot->_data << " ";
            _InOrder(pRoot->_pRight);
        }
    }
    //递归后序遍历
    void _PostOrder(pNode pRoot)
    {
        if (pRoot)
        {
            _PostOrder(pRoot->_pLeft);
            _PostOrder(pRoot->_pRight);
            cout << pRoot->_data << " ";
        }
    }
    //非递归前序遍历
    //方法一：访问根之后直接访问左子树访问完
    void _PreOrderNoR(pNode pRoot)
    {
        stack<pNode> s;
        pNode cur = pRoot;
        while (cur || !s.empty())
        {   
            while (cur)
            {
                cout << cur->_data << " ";
                s.push(cur);
                cur = cur->_pLeft;
            }//此时左子树遍历完
            //取栈顶元素访问右子树(此时栈顶元素已经访问)
            pNode top = s.top();
            s.pop();
            //子问题
            cur = top->_pRight;
        }
        cout << endl;
    }
    //方法二：
    void _PreOrderNoR2(pNode pRoot)
    {
        if (pRoot == NULL)
            return;
        stack<pNode> s;
        s.push(pRoot);//根节点入栈
        while (!s.empty())
        {
            pNode top = s.top();
            cout << top->_data << " ";
            s.pop();
            if (top->_pRight)//先压右子树
                s.push(top->_pRight);
            if (top->_pLeft)//再压左子树
                s.push(top->_pLeft);
        }
        cout << endl;
    }
    //非递归中序遍历
    void _InOrderNoR(pNode pRoot)
    {
        stack<pNode> s;
        pNode cur = pRoot;
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_pLeft;
            }//直到最左节点
            //取栈顶元素访问该元素并访问右子树
            pNode top = s.top();
            cout << top->_data << " ";
            s.pop();
            //子问题
            cur = top->_pRight;
        }
        cout << endl;
    }
    //非递归后序遍历
    void _PostOrderNoR(pNode pRoot)
    {
        stack<pNode> s;
        pNode cur = pRoot;
        pNode prev = NULL;//标记最近访问过的节点
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_pLeft;
            }//直到最左节点

            pNode top = s.top();//取栈顶元素
            if (top->_pRight == NULL || top->_pRight == prev)//判断该节点的右子树是否为空
            {                                                //再判断是不是第一次在栈顶取到该元素 
                cout << top->_data << " ";
                prev = top;
                s.pop();
            }
            else//不为空，访问右子树
            {
                cur = top->_pRight;
            }
        }
        cout << endl;
    }
    //后序遍历递归销毁二叉树
    void _DestoryBinaryTree(pNode pRoot)
    {
        if (pRoot)
            return;
        _DestoryBinaryTree(pRoot->_pLeft);
        _DestoryBinaryTree(pRoot->_pRight);
        delete pRoot;
        pRoot = NULL;
    }
    //求节点个数
    size_t _Size(pNode pRoot)
    {
        if (!pRoot)
        {
            return 0;
        }
        return _Size(pRoot->_pLeft) + _Size(pRoot->_pRight) + 1;
    }
    //求叶子节点个数
    size_t _LeafSize(pNode pRoot)
    {
        if (!pRoot)
            return 0;
        if (pRoot->_pLeft == NULL && pRoot->_pRight == NULL)
            return 1;
        return _LeafSize(pRoot->_pLeft) + _LeafSize(pRoot->_pRight);
    }
    //求第K层节点的个数
    size_t _KSize(pNode pRoot, size_t k)
    {
        if (pRoot == NULL)
            return 0;
        if (k == 1)
            return 1;
        return _KSize(pRoot->_pLeft, k - 1) + _KSize(pRoot->_pRight, k - 1);
    }
    //求二叉树高度
    size_t _Height(pNode pRoot)
    {
        if (!pRoot)
            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;
        ret = _Find(pRoot->_pLeft, data);
        if (ret)
            return ret;
        return _Find(pRoot->_pRight, data);
    }
    //找二叉树中节点的双亲节点
    pNode _FindParent(pNode pRoot, pNode node)
    {
        //树为空树   寻找的节点为空节点   寻找的节点是根节点(无双亲节点)
        if (pRoot == NULL || node == NULL || pRoot == node)
        {
            return NULL;
        }
        if (node == pRoot->_pLeft || node == pRoot->_pRight)
            return pRoot;
        if (pRoot->_pLeft)
            return _FindParent(pRoot->_pLeft, node);
        return _FindParent(pRoot->_pRight, node);
    }
    //寻找节点的左孩子
    pNode _FindLeftChild(pNode pRoot, pNode node)
    {
        if (node == NULL || pRoot == NULL)
        {
            return NULL;
        }
        pNode cur = _Find(pRoot, node->_data);
        return cur->_pLeft;
    }
    //寻找节点的右孩子
    pNode _FindRightChild(pNode pRoot, pNode node)
    {
        if (node == NULL || pRoot == NULL)
        {
            return NULL;
        }
        pNode cur = _Find(pRoot, node->_data);
        return cur->_pRight;
    }

private:
    pNode _pRoot;
};

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include "BinaryTree.h"


void FunTest1()
{
    char arr1[] = { 'A', 'B', 'D', '#', 'G', '#', '#', '#', 'C', 'E', '#', '#', 'F' };
    BinaryTree<char> bt1(arr1, sizeof(arr1) / sizeof(arr1[0]), '#');
    bt1.PreOrder();
    bt1.InOrder();
    bt1.PostOrder();
    bt1.LevelOrder();
    cout << bt1.Size() << endl;
    cout << bt1.LeafSize() << endl;
    cout << bt1.KSize(3) << endl;
    cout << bt1.Height() << endl;
    cout << bt1.KSize(4) << endl;

    BinaryTreeNode<char>* ret1 = bt1.Find('B');
    BinaryTreeNode<char>* ret2 = bt1.FindParent(ret1);
    BinaryTreeNode<char>* ret3 = bt1.FindLeftChild(ret1);
    BinaryTreeNode<char>* ret4 = bt1.FindRightChild(ret1);
    bt1.PreOrderNoR();
    bt1.InOrderNoR();
    bt1.PostOrderNoR();
}

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

结果在这里不做演示，读者可以自行测试。
(注：对二叉树中常见的面试题做出整理后，会附上链接)

【数据结构】二叉树的简单操作及简单应用
wakawaka
12-03 995
简介： 二叉树的应用十分广泛。根据二叉树的前序序列和中序序列，可以构造出二叉树。构造方法可以采用递归和非递归。二叉树的遍历通常有四种方法，分别是前序遍历，中序遍历，后序遍历，层序遍历。其中，前序，中序，后序又有递归和非递归两种写法。求最近公共祖先的方法同样有很多。这里选择了一种时间、空间复杂度较低的方法。 本文主要分为以下几个部分： 递归与非递归建树 不同方式的遍历
java编程实现数据结构中二叉树的构建代码
最新发布
07-23
在计算机科学领域，二叉树是一种重要的数据结构，它是每个节点最多有两个子节点的树形结构。在Java编程语言中，实现二叉树的构建通常涉及到创建节点类、插入节点以及遍历树等操作。本文将详细介绍如何使用Java语言来...
二叉树的实现
qq_45738497的博客
12-09 300
#include<iostream> #include<cstdio> #include<string> using namespace std; struct BiNode { char data; BiNode * rchild,*lchilld; }; class BiTree { public: Bitree(); void preorder(); void inorder(); void postorde.
【数据结构】 二叉树
qq_56251766的博客
06-07 1038
二叉树的相关操作和OJ题
二叉树 数据结构
05-10 435
实验四 二叉树子系统 1.实验目的 （1）掌握二叉树的特点及其存储方式。 （2）掌握二叉树的创建和显示方法。 （3）复习二叉树遍历的概念，掌握二叉树遍历的基本方法。 2．实验内容 （1）按屏幕提示用前序方法建立一棵二叉树。 （2）编写各个函数：前序遍历、中序遍历、后序遍历、层次遍历、求二叉树的叶子结点数、求二叉树的总结点数、求二叉树的深度。 （3）设计一个选择式菜单，...
二叉树数据结构
weixin_30268071的博客
01-22 138
1. Js二叉树数据的创建 function Node(data,left,right) { this.data = data; this.left = left; this.right = right; } //定义插入对象 function BST(){ ...
数据结构：二叉树的操作
碧瑶的博客呀
07-15 405
二叉树采用二叉链表的数据结构，实现以下操作： 二叉树的先序、中序、后序遍历 二叉树的三个遍历采用递归方法，先序表示先遍历根结点，再遍历左子树，然后遍历右子树，中序表示先遍历左子树，再遍历根结点，再遍历右子树，后序表示先遍历左子树，再遍历右子树，再遍历根结点，例如： 此二叉树先序遍历递归过程为到达A，不为空，输出A，调用左子树到达B,不为空，输出B，调用B的左子树到达D,不为空，输出D，调用D的...
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构平衡二叉树的操作演示
05-07
数据结构平衡二叉树的操作演示 本篇文章将对平衡二叉树的操作演示进行详细的介绍，包括创建表、查找、插入、删除、合并、分裂六种操作。并对平衡二叉树的实现过程进行了详细的设计和分析。 一、概要设计 平衡...
数据结构-二叉树Java实现及其遍历算法
09-24
二叉树是一种常见的数据结构，它在计算机科学中占有重要地位，尤其是在实现各种算法中，包括搜索、排序和树形结构的表示等。二叉树的每个节点最多有两个子节点，通常称为左子节点和右子节点。 Java是一种广泛使用的...
合工大数据结构实验 二叉树
04-14
在计算机科学领域，数据结构是组织和管理大量数据的关键组成部分，它直接影响到程序的效率和性能。本实验的主题是“二叉树”，这是数据结构中一个基础且重要的概念。二叉树是一种非线性的数据结构，由节点（或称为...
数据结构二叉树操作
sanpiao_0527的博客
12-04 429
#include #include #include #define TRUE 1#define FALSE 0#define ERROR 0#define OK 1#define Stack_Size 50 /*栈的最大长度*/#define MAXSIZE 50 /*队列的最大长度*/typedef char DataType;typedef struct Node{ Data
数据结构二叉树基本操作
qq_52321992的博客
04-23 872
/* *@author：orsrrc *优快云:https://blog.youkuaiyun.com/qq_52321992?type=blog * 博客园：https://www.cnblogs.com/orsrrc/ */ 注：本篇中涉及C++中的传递引用等方法，所以在创建源文件时文件后缀为.cpp，.cpp文件是向下兼容的，所以当我们使用C语言语句也可以编译成功。 由于使用VS编译时采用新的规则，原本的Scanf函数等不适用本规则会提示使用scanf_f函数或者_CRT_SECURE_NO_WARNING
『数据结构』二叉树
叄拾叄画生
04-11 565
树的简介。树的表示。二叉树概念及结构。二叉树的五种基本形态。特殊的二叉树：满二叉树，完全二叉树。二叉树的存储结构：顺序存储，链式存储。二叉树接口实现（C语言和Java）。
数据结构_二叉树相关操作
qq_40995354的博客
05-23 222
二叉树的表示方法有很多种：双亲表示法，孩子表示法，双亲孩子表示法，孩子兄弟表示法。 在这里我们用孩子表示法 创建二叉树 树的拷贝 首先，拷贝分两种：浅拷贝和深拷贝 浅拷贝：两个对象同时指向同一块内存，修改一个，另一个也会被修改。 深拷贝：原有所有对象，包括内存复制一份。 fork 中的拷贝是特殊的拷贝，刚开始时浅拷贝，这样减少了空间浪费。要修改时的一瞬间，再深拷贝。 树的拷...
C++实现数据结构中的二叉树算法详解
“C++实现数据结构中的各种算法，包括二叉树的节点类BinTreeNode的定义和相关操作。” 在C++编程中，数据结构和算法是核心部分，它们对于高效地处理和存储数据至关重要。这篇内容主要涉及了二叉树这一数据结构的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值