【数据结构(C++实现)】：二叉树的定义、性质、各种操作及其实现

最新推荐文章于 2024-03-10 15:20:09 发布
最新推荐文章于 2024-03-10 15:20:09 发布
阅读量9.5k 收藏 149
点赞数 31
分类专栏： 数据结构 文章标签： 二叉树 模板实现 完全二叉树 各种操作 二叉查找树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bqw18744018044/article/details/81871726
版权

目录

树

二叉树

二叉树的各种操作(C++)

        二叉树的结点定义

        二叉树接口的定义

        插入

        删除

        先序遍历

        中序遍历

        后序遍历

        层次遍历

        树的高度

完整代码

其他类型的树

二叉查找(搜索)树

2-3叉树

红黑树

AVL树

B树

B+树

  • 树

  • 二叉树

  • 二叉树的各种操作(C++)

        二叉树的结点定义

/*二叉树结点*/
template <typename T>
class BiTreeNode{
public:
    T data;
    BiTreeNode<T>* left;
    BiTreeNode<T>* right;
    BiTreeNode(T data){
        this->data = data;
        this->left = NULL;
        this->right = NULL;
    }
};

        二叉树接口的定义

template <typename T>
class BiTree{
private:
    int size;/*树中结点的个数*/
public:
    BiTreeNode<T>* root;/*根结点的指针*/

    BiTree(){size=0;root=NULL;};
    ~BiTree(){remove(root);};

    bool insert_left(BiTreeNode<T>* node,T data);/*将data插入到node的左孩子*/
    bool insert_right(BiTreeNode<T>* node,T data);/*将data插入到node的右孩子*/
    bool remove(BiTreeNode<T>* &node);/*删除以node为根的子树*/
    bool preorderR(BiTreeNode<T>* node,list<T>* l);/*递归实现：先序遍历以node为根的树，并将遍历结果保存到l中*/
    bool preorderI(BiTreeNode<T>* node,list<T>* l);/*迭代实现：先序遍历以node为根的树，并将遍历结果保存到l中*/
    bool inorderR(BiTreeNode<T>* node,list<T>* l);/*递归实现：中序遍历以node为根的树，并将遍历结果保存到l中*/
    bool inorderI(BiTreeNode<T>* node,list<T>* l);/*迭代实现：中序遍历以node为根的树，并将遍历结果保存到l中*/
    bool postorderR(BiTreeNode<T>* node,list<T>* l);/*递归实现：后序遍历以node为根的树，并将遍历结果保存到l中*/
    bool postorderI(BiTreeNode<T>* node,list<T>* l);/*迭代实现：后序遍历以node为根的树，并将遍历结果保存到l中*/
    bool level(BiTreeNode<T>* node,list<T>* l);/*层次遍历以node为根的树，并将变量结果保存到l中*/
    int height(BiTreeNode<T>* node);/*以node为根的树的高度*/
};

        插入

/**************************************************************************
Function:insert_left
Description:将data插入到node的左孩子
Input:二叉树结点node,数据data
Output:插入是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::insert_left(BiTreeNode<T>* node,T data){
    if(node==NULL){//允许空树插入结点
        if(size>0)
            return false;
        else
            root = new BiTreeNode<T>(data);
    }else{
        if(node->left!=NULL)
            return false;
        else
            node->left = new BiTreeNode<T>(data);
    }
    size++;
    return true;
}
/**************************************************************************
Function:insert_right
Description:将data插入到node的右孩子
Input:二叉树结点node,数据data
Output:插入是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::insert_right(BiTreeNode<T>* node,T data){
    if(node==NULL){
        if(size>0)
            return false;
        else
            root = new BiTreeNode<T>(data);
    }else{
        if(node->right!=NULL)
            return false;
        else
            node->right = new BiTreeNode<T>(data);
    }
    size++;
    return true;
}

        删除

/**************************************************************************
Function:remove
Description:删除以node为根的子树
Input:二叉树结点node的引用
Output:删除是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::remove(BiTreeNode<T>* &node){
    /*之所以要传入指针的引用，是因为不但要释放node指向的空间，
    同样也需要将node内保存的地址更改为NULL*/
    if(node==NULL)
        return false;
    if(remove(node->left)&&remove(node->right)){
        delete node;//释放p指向的空间
        node = NULL;//清空p内的地址
        size--;
        return true;
    }else
        return false;
}

        先序遍历

              (1).规则：先访问根结点，然后按规则遍历左子树，再按规则遍历右子树；图2中的树先序遍历的结果为：124895367；

              (2).递归实现

template <typename T>
bool BiTree<T>::preorderR(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    l->push_back(node->data);
    preorderR(node->left,l);
    preorderR(node->right,l);
    return true;
}

              (3).迭代实现

template <typename T>
bool BiTree<T>::preorderI(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    stack<BiTreeNode<T>*> s;
    BiTreeNode<T>* p = node;
    while(p!=NULL||!s.empty()){
        if(p!=NULL){
            //压入栈时输出
            l->push_back(p->data);
            s.push(p);
            p = p->left;
        }else{
            p = s.top();
            s.pop();
            p = p->right;
        }
    }
    return true;
}

        中序遍历

              (1).先中序遍历左子树，再访问根结点，最后中序遍历右子树；图2中的树中序遍历结果：849251637；

              (2).递归实现

template <typename T>
bool BiTree<T>::inorderR(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    inorderR(node->left,l);
    l->push_back(node->data);
    inorderR(node->right,l);
    return true;
}

              (3).迭代实现

template <typename T>
bool BiTree<T>::inorderI(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    stack<BiTreeNode<T>*> s;
    BiTreeNode<T>* p = node;
    while(!s.empty()||p!=NULL){
        if(p!=NULL){
            s.push(p);
            p = p->left;//下一个该访问的结点
        }else{
            p = s.top();
            s.pop();//要访问就弹出
            l->push_back(p->data);//弹出栈时输出
            p = p->right;//下一个该访问的结点
        }
    }
    return true;
}

        后序遍历

              (1).后序遍历左子树，再后序遍历右子树，最终访问根结点；图2中的树后序遍历的结果：894526731；

              (2).递归实现

template <typename T>
bool BiTree<T>::postorderR(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    postorderR(node->left,l);
    postorderR(node->right,l);
    l->push_back(node->data);
    return true;
}

              (3).迭代实现

template <typename T>
bool BiTree<T>::postorderI(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    stack<BiTreeNode<T>*> s;
    BiTreeNode<T>* p = node;
    BiTreeNode<T>* pre = NULL;//用于标记先前访问过的结点
    while(!s.empty()||p!=NULL){
        if(p!=NULL){
            s.push(p);
            p = p->left;
        }else{
            BiTreeNode<T>* right = s.top()->right;
            if(right!=NULL&&right!=pre){
                p = right;
            }else{
                //在p==NULL且right!=NULL&&right!=pre时，
                //说明要访问栈顶结点了
                pre = s.top();
                l->push_back(pre->data);
                s.pop();
            }
        }
    }
    return true;
}

        层次遍历

              (1).从上到下，从左到右依次访问结点；图2中的树层次遍历结果为：123456789；

              (2).实现（需要借助队列）

template <typename T>
bool BiTree<T>::level(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    queue<BiTreeNode<T>*> q;
    q.push(node);
    BiTreeNode<T>* p = NULL;
    while(!q.empty()){
        p = q.front();
        q.pop();
        l->push_back(p->data);
        if(p->left!=NULL)q.push(p->left);
        if(p->right!=NULL)q.push(p->right);
    }
    return true;
}

        树的高度

template <typename T>
int BiTree<T>::height(BiTreeNode<T>* node){
    if(node==NULL)
        return 0;
    int left_height = height(node->left);
    int right_height = height(node->right);
    return max(left_height,right_height)+1;
}

  • 完整代码


/*数据结构：二叉树*/

#include <iostream>
#include <list>
#include <stack>
#include <queue>

using namespace std;

/*二叉树结点*/
template <typename T>
class BiTreeNode{
public:
    T data;
    BiTreeNode<T>* left;
    BiTreeNode<T>* right;
    BiTreeNode(T data){
        this->data = data;
        this->left = NULL;
        this->right = NULL;
    }
};

template <typename T>
class BiTree{
private:
    int size;/*树中结点的个数*/
public:
    BiTreeNode<T>* root;/*根结点的指针*/

    BiTree(){size=0;root=NULL;};
    ~BiTree(){remove(root);};

    bool insert_left(BiTreeNode<T>* node,T data);/*将data插入到node的左孩子*/
    bool insert_right(BiTreeNode<T>* node,T data);/*将data插入到node的右孩子*/
    bool remove(BiTreeNode<T>* &node);/*删除以node为根的子树*/
    bool preorderR(BiTreeNode<T>* node,list<T>* l);/*递归实现：先序遍历以node为根的树，并将遍历结果保存到l中*/
    bool preorderI(BiTreeNode<T>* node,list<T>* l);/*迭代实现：先序遍历以node为根的树，并将遍历结果保存到l中*/
    bool inorderR(BiTreeNode<T>* node,list<T>* l);/*递归实现：中序遍历以node为根的树，并将遍历结果保存到l中*/
    bool inorderI(BiTreeNode<T>* node,list<T>* l);/*迭代实现：中序遍历以node为根的树，并将遍历结果保存到l中*/
    bool postorderR(BiTreeNode<T>* node,list<T>* l);/*递归实现：后序遍历以node为根的树，并将遍历结果保存到l中*/
    bool postorderI(BiTreeNode<T>* node,list<T>* l);/*迭代实现：后序遍历以node为根的树，并将遍历结果保存到l中*/
    bool level(BiTreeNode<T>* node,list<T>* l);/*层次遍历以node为根的树，并将变量结果保存到l中*/
    int height(BiTreeNode<T>* node);/*以node为根的树的高度*/
};

/**************************************************************************
Function:insert_left
Description:将data插入到node的左孩子
Input:二叉树结点node,数据data
Output:插入是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::insert_left(BiTreeNode<T>* node,T data){
    if(node==NULL){//允许空树插入结点
        if(size>0)
            return false;
        else
            root = new BiTreeNode<T>(data);
    }else{
        if(node->left!=NULL)
            return false;
        else
            node->left = new BiTreeNode<T>(data);
    }
    size++;
    return true;
}
/**************************************************************************
Function:insert_right
Description:将data插入到node的右孩子
Input:二叉树结点node,数据data
Output:插入是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::insert_right(BiTreeNode<T>* node,T data){
    if(node==NULL){
        if(size>0)
            return false;
        else
            root = new BiTreeNode<T>(data);
    }else{
        if(node->right!=NULL)
            return false;
        else
            node->right = new BiTreeNode<T>(data);
    }
    size++;
    return true;
}

/**************************************************************************
Function:remove
Description:删除以node为根的子树
Input:二叉树结点node的引用
Output:删除是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::remove(BiTreeNode<T>* &node){
    /*之所以要传入指针的引用，是因为不但要释放node指向的空间，
    同样也需要将node内保存的地址更改为NULL*/
    if(node==NULL)
        return false;
    if(remove(node->left)&&remove(node->right)){
        delete node;//释放p指向的空间
        node = NULL;//清空p内的地址
        size--;
        return true;
    }else
        return false;
}

/**************************************************************************
Function:preorderR、preorderI
Description:先序遍历以node为根的数，并将遍历结果保存到l中
Input:二叉树结点node，列表l
Output:遍历是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::preorderR(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    l->push_back(node->data);
    preorderR(node->left,l);
    preorderR(node->right,l);
    return true;
}
template <typename T>
bool BiTree<T>::preorderI(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    stack<BiTreeNode<T>*> s;
    BiTreeNode<T>* p = node;
    while(p!=NULL||!s.empty()){
        if(p!=NULL){
            //压入栈时输出
            l->push_back(p->data);
            s.push(p);
            p = p->left;
        }else{
            p = s.top();
            s.pop();
            p = p->right;
        }
    }
    return true;
}
/**************************************************************************
Function:inorderR、inorderI
Description:中序遍历以node为根的数，并将遍历结果保存到l中
Input:二叉树结点node，列表l
Output:遍历是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::inorderR(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    inorderR(node->left,l);
    l->push_back(node->data);
    inorderR(node->right,l);
    return true;
}
template <typename T>
bool BiTree<T>::inorderI(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    stack<BiTreeNode<T>*> s;
    BiTreeNode<T>* p = node;
    while(!s.empty()||p!=NULL){
        if(p!=NULL){
            s.push(p);
            p = p->left;//下一个该访问的结点
        }else{
            p = s.top();
            s.pop();//要访问就弹出
            l->push_back(p->data);//弹出栈时输出
            p = p->right;//下一个该访问的结点
        }
    }
    return true;
}
/**************************************************************************
Function:postorderR、postorderI
Description:后序遍历以node为根的数，并将遍历结果保存到l中
Input:二叉树结点node，列表l
Output:遍历是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::postorderR(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    postorderR(node->left,l);
    postorderR(node->right,l);
    l->push_back(node->data);
    return true;
}
template <typename T>
bool BiTree<T>::postorderI(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    stack<BiTreeNode<T>*> s;
    BiTreeNode<T>* p = node;
    BiTreeNode<T>* pre = NULL;//用于标记先前访问过的结点
    while(!s.empty()||p!=NULL){
        if(p!=NULL){
            s.push(p);
            p = p->left;
        }else{
            BiTreeNode<T>* right = s.top()->right;
            if(right!=NULL&&right!=pre){
                p = right;
            }else{
                //在p==NULL且right!=NULL&&right!=pre时，
                //说明要访问栈顶结点了
                pre = s.top();
                l->push_back(pre->data);
                s.pop();
            }
        }
    }
    return true;
}
/**************************************************************************
Function:level
Description:层次遍历以node为根的树，并将变量结果保存到l中
Input:二叉树结点node，列表l
Output:遍历是否成功
***************************************************************************/
template <typename T>
bool BiTree<T>::level(BiTreeNode<T>* node,list<T>* l){
    if(node==NULL||l==NULL)
        return false;
    queue<BiTreeNode<T>*> q;
    q.push(node);
    BiTreeNode<T>* p = NULL;
    while(!q.empty()){
        p = q.front();
        q.pop();
        l->push_back(p->data);
        if(p->left!=NULL)q.push(p->left);
        if(p->right!=NULL)q.push(p->right);
    }
    return true;
}

/**************************************************************************
Function:height
Description:以node为根的树的高度
Input:二叉树结点node
Output:树的高度
***************************************************************************/
template <typename T>
int BiTree<T>::height(BiTreeNode<T>* node){
    if(node==NULL)
        return 0;
    int left_height = height(node->left);
    int right_height = height(node->right);
    return max(left_height,right_height)+1;
}

int main(){
    BiTree<int>* biTree = new BiTree<int>();
    /*
    构建二叉树：
       3
     6   2
    8 9
    */
    biTree->insert_left(biTree->root,3);
    biTree->insert_left(biTree->root,6);
    biTree->insert_right(biTree->root,2);
    biTree->insert_left(biTree->root->left,8);
    biTree->insert_right(biTree->root->left,9);
    list<int> l;
    list<int>::iterator iter;
    //先序遍历
    biTree->preorderR(biTree->root,&l);
    cout<<endl<<"先序遍历(递归)：";
    for(iter=l.begin();iter!=l.end();iter++)
        cout<<*iter<<",";
    l.clear();
    biTree->preorderI(biTree->root,&l);
    cout<<endl<<"先序遍历(迭代)：";
    for(iter=l.begin();iter!=l.end();iter++)
        cout<<*iter<<",";
    l.clear();

    //中序遍历
    biTree->inorderR(biTree->root,&l);
    cout<<endl<<"中序遍历(递归)：";
    for(iter=l.begin();iter!=l.end();iter++)
        cout<<*iter<<",";
    l.clear();
    biTree->inorderI(biTree->root,&l);
    cout<<endl<<"中序遍历(迭代)：";
    for(iter=l.begin();iter!=l.end();iter++)
        cout<<*iter<<",";
    l.clear();

    //后序遍历
    biTree->postorderR(biTree->root,&l);
    cout<<endl<<"后序遍历(递归)：";
    for(iter=l.begin();iter!=l.end();iter++)
        cout<<*iter<<",";
    l.clear();
    biTree->postorderI(biTree->root,&l);
    cout<<endl<<"后序遍历(迭代)：";
    for(iter=l.begin();iter!=l.end();iter++)
        cout<<*iter<<",";
    l.clear();

    //层次遍历
    biTree->level(biTree->root,&l);
    cout<<endl<<"层次遍历：";
    for(iter=l.begin();iter!=l.end();iter++)
        cout<<*iter<<",";
    l.clear();
    cout<<endl<<biTree->height(biTree->root);
    delete biTree;
}

  • 其他类型的树

  1. 二叉查找(搜索)树

  2. 2-3叉树

  3. 红黑树

  4. AVL树

  5. B树

  6. B+树

BQW_
关注
  • 31
    点赞
  • 踩
  • 149
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
《数据结构——C++实现》（第二版）课本源代码
04-25
《数据结构——C++实现》（第二版）课本源代码，很全很给力
c++的二叉树
热门推荐
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
C++实现二叉树
最新发布
qq_45285738的博客
03-10 537
接下来，你将看到，输出先序、层序遍历结果等内容，如下：（注：中序后序，操作类似于前序遍历，没有实现）1.2 实现二叉树的访问 --- 先中后序访问、层序访问。1.3 计算树的深度、节点数、复制树。2.1 首先创建出一棵二叉树。1.1 实现二叉树的创建。
数据结构之二叉树（c++）
qq_57541265的博客
03-19 8251
本文章主要介绍二叉树的概念，二叉树的存储结构，二叉树的插入，删除，查找，遍历，等操作
二叉树详解（C++）
qq_54169998的博客
11-04 9143
树状图是一种数据结构，它是由 n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树； 专业术语 中 文 描 述 根节点 一棵树的顶点 孩子节点 一个结点含有的子树的根结点称为该结点的子结点 叶子节点 .
c++二叉树详解（附基本操作代码版）
Yoyo的博客
07-10 4136
二叉树可以说是树形数据结构中最基础的，且在多种领域都有应用（比如语法树，二值决策树），熟悉其各种操作是必须的。char data;}BT;// 根据输入二点中序表达式和前序表达式创建一颗二叉树// 展示一颗二叉树，以A(B, C(D, E))这样加了括号的前序遍历来实现// 销毁二叉树// 判断这颗树是不是完全二叉树// 计算树的高度// 计算叶子的数量// 计算树的宽度// 层次遍历// 前序遍历// 中序遍历// 后序遍历。
数据结构与算法实验（C++）：二叉树实验-代码
01-18
1）定义二叉链类，实现二叉树的基本操作算法； 2）在主函数中定义对象，并调用成员函数，验证二叉链的基本操作。具体包括： a.建立二叉链存储的二叉树 b.遍历二叉树：前序、中序、后序和层序 c.求二叉树的深度 d....
数据结构C++版-二叉树实验-使用类模板的方式实现
11-27
一、实验目的：1、实现二叉树的存储结构（二叉链表或三叉链表等存储结构任选）2、熟悉二叉树基本术语的含义3、掌握使用栈和队列及递归思想完成二叉树相关操作的编程实现二、实验内容: 主要完成以下功能:1....
数据结构实验：二叉树的基本操作
12-04
南邮数据结构实验使用C++描述，二叉树的基本操作
二叉树的基本操作实现及其应用
05-24
设计程序实现二叉树结点的类型定义和对二叉树的基本操作。该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。 1. 按先序次序建立一个二叉树 ，用#表示某结点的左右子树是否为空，用于表示该结点是否...
C++实现二叉树基本操作详解
12-26
树是一种重要的非线性数据结构，二叉树是树型结构的一种重要类型。本学年论文介绍了二叉树的定义，二叉树的存储结构，二叉树的相关术语，以此引入二叉树这一概念，为展开二叉树的基本操作做好理论铺垫。二叉树的基本...
C++数据结构实验三：树的应用
01-16
4. 掌握树和二叉树的逻辑结构特点、二叉树的顺序存储结构、二叉树的链式存储结构——二叉链表、二叉链表的结构体类型定义、在二叉链表存储结构上先序遍历、中序遍历、后序遍历的实现算法。 实验内容 1、以字符串...
北京邮电大学_信通院_数据结构_二叉树 C++
03-16
根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。 二叉树的基本功能： 1、二叉树的建立 2、前序遍历二叉树 3、中序遍历二叉树 4、后序遍历二叉树 5、按层序遍历二叉树 6、求二叉树的深度 7、求指定...
C++数据结构实验五：查找排序
01-16
1．掌握哈希表的定义，哈希函数的构造方法。 2．掌握并比较各种排序算法。 3. 掌握查找的概念、静态查找与动态查找、顺序查找、二分查找、索引查找等算法思想。 4. 掌握二叉排序树的概念、平衡二叉树等算法思想。 5....
二叉树的实现
08-25
1、 定义链接存储的二叉树类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建一棵二叉树，并对其初始化； 2）先根、中根、后根遍历二叉树(递归算法)； 3）在二叉树中搜索给定结点的父结点； 4）搜索...
二叉树的宽度求解问题（C++数据结构）
12-26
设二叉树的宽度定义为具有结点数最多的那一层上的结点个数。试设计算法求二叉树的宽度，并输出各结点的高度。（包含提高）
c++ || 详解二叉树
LQEmptycity的博客
08-17 1065
树
C++实现树 - 02 二叉树
Newin2020的博客
05-04 4976
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
C++数据结构——二叉树
caijiandl的博客
07-31 3258
二叉树 项目 项目 项目 项目1 项目2 项目3 计划任务 完成任务 二叉搜索树 二叉搜索树是二叉树的一种特殊形式。 二叉搜索树具有以下性质：每个节点中的值必须大于（或等于）其左侧子树中的任何值，但小于（或等于）其右侧子树中的任何值。 我们将在本章中更详细地介绍二叉搜索树的定义，并提供一些与二叉搜索树相关的习题。 完成本卡片后，你将： 理解二叉搜索树的特性 熟悉在二叉搜索树中的基本操作 理解高度平衡二叉搜索树的概念 二叉搜索树的定义 **二叉搜索树（BST）**是二叉树的一种
数据结构C＋＋二叉树的代码实现先序中序后序遍历
11-03
```C++ //定义二叉树结点 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 先序遍历 void preorderTraversal(TreeNode* root) { if (root == NULL) return; cout << root->val << " "; preorderTraversal(root->left); preorderTraversal(root->right); } //中序遍历 void inorderTraversal(TreeNode* root) { if (root == NULL) return; inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } //后序遍历 void postorderTraversal(TreeNode* root) { if (root == NULL) return; postorderTraversal(root->left); postorderTraversal(root->right); cout << root->val << " "; } ``` --相关问题--: 1. 如何构建一棵二叉树？ 2. 二叉树的其他遍历方式有

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BQW_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值