二叉树类型题合集(左神算法初级班C++实现)

最新推荐文章于 2023-06-25 15:38:17 发布
最新推荐文章于 2023-06-25 15:38:17 发布
阅读量303 收藏 2
点赞数 2
分类专栏： c++ 算法 文章标签： 二叉树 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45797026/article/details/115352379
版权
算法 同时被 2 个专栏收录
110 篇文章 5 订阅
订阅专栏
c++
58 篇文章 1 订阅
订阅专栏

文章目录

二叉树类型题合集

是否为搜索二叉树

事实上如果一个二叉树中序遍历的结果是升序的，它就是一颗搜索二叉树，所以，我们可以在中序遍历的基础上改

先来定义节点

struct Node {
    int value;
    Node *left;
    Node *right;

    Node() : value(0), left(nullptr), right(nullptr) {}

    

    Node(int x, Node *left, Node *right) : value(x), left(left), right(right) {}
};

这个节点的定义方法我参考了leetcode

然后我们看如何利用结点，搭建起一棵二叉树

Node* bT(){
    Node * head = new Node(8);
    head->left = new Node(6);
    head->right = new Node(10);
    head->left->left = new Node(4);
    head->left->right = new Node(7);
    head->left->left->left = new Node(1);
    head->left->left->right = new Node(5);
    head->right->left = new Node(9);
    head->right->right = new Node(11);
    return head;
}

上面的代码搭建了如下一颗二叉树，然后返回它的头节点地址

在这里插入图片描述

然后是递归版本和非递归版本的中序遍历

//递归版中序遍历
void inOrderRecur(Node *head){
    if(!head){
        return;
    }
    inOrderRecur(head->left);
    cout<<head->value<<" ";
    inOrderRecur(head->right);
}

//非递归版中序遍历
void inOrderUnRecur(Node* head){
    cout<<endl;
    if(head){
        auto *sta = new stack<Node*>() ;
        while(!sta->empty()||head){
            if(head){
                sta->push(head);
                head = head->left;
            }else{
                head = sta->top();
                sta->pop();
                cout<<head->value<<" ";
                head = head->right;
            }
        }
    }
    cout<<endl;
}

然后可以写代码测试一下结果

void test(){
    inOrderRecur(bT());
    inOrderUnRecur(bT());
}

int main(){
    test();
    return 0;
}

输出结果如下

1 4 5 6 7 8 9 10 11
1 4 5 6 7 8 9 10 11

这样我们可以明显的看出上面的二叉树是一颗搜索二叉树

然后对中序遍历的代码稍作更改

//递归版本
int preValue = -10000;
bool isBST(Node *head){
    if(!head){
         return true;
    }
    bool isLeftBst = isBST(head->left);
    if(!isLeftBst)//判断左数是不是搜索二叉树，不是的话返回false
        return false;
    if(head->value<=preValue)//看看当前节点是否比前一个节点小，如果小，返回false
        return false;
    else
        preValue  = head->value;//如果大，那当前值设置为preValue;
    //右树如果是搜索二叉树，那么整棵树是搜索二叉树，如果不是那么整棵树都不是
    return isBST(head->right);
}

//非递归版本
bool isBSTUnRecur(Node* head){

    if(head){
        int preValue = -10000;
        auto *sta = new stack<Node*>() ;
        while(!sta->empty()||head){
            if(head){
                sta->push(head);
                head = head->left;
            }else{
                head = sta->top();
                sta->pop();
                if(head->value<=preValue)
                    return false;
                else
                    preValue = head->value;
                head = head->right;
            }
        }
    }
    return true;
}

2、判断是否完全二叉树

这道题主要用的方法是BFS，即宽度优先遍历

判断条件如下：

（1）任何一个节点，有右孩子而无左孩子，返回false

（2）遇到一个有左无右的节点后，必须保证后面的所有节点都是叶节点，否则不是完全二叉树

bool isCBT(Node*head){
    if(head == nullptr){
        return true;
    }
    auto *que = new queue<Node*>();
    //是否遇到过左右两个孩子不双全的节点
    bool leaf = false;
    Node *l = nullptr;
    Node *r = nullptr;
    que->push(head);
    while(!que->empty()){
        head = que->front();
        que->pop();
        l = head->left;
        r = head->right;
        if( (leaf&&(l||r))//条件二
        ||(!l&&r)){//条件一
            return false;
        }
        if(l) que->push(l);
        if(r) que->push(r);
        if(!l||!r) leaf = true;//左右孩子不双全
    }
    return true;
}

3、判断是否是满二叉树

先求二叉树的最大深度，再求二叉树的节点个数N，二者满足如下关系则说明是满二叉树，代码在下一个问题解决之后再展示
N = 2 l − 1 N = 2^l -1 N=2l−1

4、判断是否平衡二叉树（二叉树题目套路）

平衡二叉树是指：对与任何一棵子树，左子树和右子树的高度差都不能超过1

struct ReturnType{
    bool isBalanced;
    int height;
    ReturnType(bool isB, int hei):isBalanced(isB),height(hei){}
};

ReturnType* process(Node* x){
    
    //base case
    if(!x) return new ReturnType(true, 0);

    ReturnType leftData = *process(x->left);
    ReturnType rightData = *process(x->right);

    int height = max(leftData.height, rightData.height)+1;

    bool isBalanced = leftData.isBalanced&&rightData.isBalanced
            &&abs(leftData.height-rightData.height)<2;
    ReturnType *ans = new ReturnType(isBalanced, height);

    return ans;

}
bool isBalanced(Node * head){
    return process(head)->isBalanced;
}

用上面的套路也可以写搜索二叉树的判断

判断条件如下：

（1）左子树是否搜索二叉树

（2）右子树是否搜索二叉树

（3）左边的最大值是否小于右树的最小值

所以我们需要的返回值类型，

如下：（1）是否是搜索二叉树

​ （2）整棵树的最小值

​ （3）整棵树的最大值

struct ReturnData{
    bool isBST;
    int min;
    int max;
    ReturnData(bool is, int mi, int ma):isBST(is), min(mi), max(ma){}
};

ReturnData * process1(Node *x){
    if(!x){
        return nullptr;
    }
    ReturnData* leftData = process1(x->left);
    ReturnData* rightData = process1(x->right);

    int Min = x->value;
    int Max = x->value;
    if(leftData){
        Min = min(Min, leftData->min);
        Max = max(Max, leftData->max);
    }
    if(rightData){
        Min = min(Min, leftData->min);
        Max = max(Max, leftData->max);
    }

//    bool isBST = true;
//    if(leftData&&(!leftData->isBST || leftData->max>=x->value))
//        isBST = false;
//    if(rightData&&(!rightData->isBST || rightData->min<=x->value))
//        isBST = false;

    bool isBST = false;
    if(
            (leftData?(leftData->isBST&&leftData->max<x->value): true)
            &&(rightData?(leftData->isBST&&leftData->max<x->value):true)
            ){
        isBST = true;
    }

    return new ReturnData(isBST, Min, Max);
}

bool isBST1(Node * x){
    return process1(x)->isBST;
}

上面的这种套路，据左神说，可以解决一切树形DP的问题，

这个套路有两个方面，第一个方面是你怎么想这个问题：第一就是可以从左右两边来获取信息

第二个方面是，怎么写代码，代码结构是什么都一目了然

按照这个套路，我们开始解决满二叉树的问题

struct Info{
    int height;
    int nodes;
    Info(int h, int n){
        height = h;
        nodes = n;
    }

};

Info* processInfo(Node *x){
    if(!x) return new Info(0, 0);
    Info * leftData = processInfo(x->left);
    Info * rightData = processInfo(x->right);
    int height = max(leftData->height, rightData->height)+1;
    int nodes = leftData->nodes + rightData->nodes + 1;
    return new Info(height, nodes);
}

bool isF(Node *head){
    if(!head) return true;
    Info *data = processInfo(head);
    return data->nodes == (1<<data->height-1);//相当于2^l-1

}

下面放一下刚才的所有代码

#include <iostream>
#include<stack>
#include<queue>
#include<cmath>
using namespace std;
struct Node {
    int value;
    Node *left;
    Node *right;

    Node() : value(0), left(nullptr), right(nullptr) {}

    Node(int x) : value(x), left(nullptr), right(nullptr) {}

    Node(int x, Node *left, Node *right) : value(x), left(left), right(right) {}
};
//------------------------是否是搜索二叉树----------------------

//递归版中序遍历
void inOrderRecur(Node *head){
    if(!head){
        return;
    }
    inOrderRecur(head->left);
    cout<<head->value<<" ";
    inOrderRecur(head->right);
}
//递归版本判断搜索二叉树
int preValue = -10000;
bool isBST(Node *head){
    if(!head){
         return true;
    }
    bool isLeftBst = isBST(head->left);
    if(!isLeftBst)//判断左数是不是搜索二叉树，不是的话返回false
        return false;
    if(head->value<=preValue)//看看当前节点是否比前一个节点小，如果小，返回false
        return false;
    else
        preValue  = head->value;//如果大，那当前值设置为preValue;
    //右树如果是搜索二叉树，那么整棵树是搜索二叉树，如果不是那么整棵树都不是
    return isBST(head->right);
}
//非递归版中序遍历
void inOrderUnRecur(Node* head){
    cout<<endl;
    if(head){
        auto *sta = new stack<Node*>() ;
        while(!sta->empty()||head){
            if(head){
                sta->push(head);
                head = head->left;
            }else{
                head = sta->top();
                sta->pop();
                cout<<head->value<<" ";
                head = head->right;
            }
        }
    }
    cout<<endl;
}
//非递归版本
bool isBSTUnRecur(Node* head){

    if(head){
        int preValue = -10000;
        auto *sta = new stack<Node*>() ;
        while(!sta->empty()||head){
            if(head){
                sta->push(head);
                head = head->left;
            }else{
                head = sta->top();
                sta->pop();
                if(head->value<=preValue)
                    return false;
                else
                    preValue = head->value;
                head = head->right;
            }
        }
    }
    return true;
}
//--------------是否是完全二叉树------------------------
bool isCBT(Node*head){
    if(head == nullptr){
        return true;
    }
    auto *que = new queue<Node*>();
    //是否遇到过左右两个孩子不双全的节点
    bool leaf = false;
    Node *l = nullptr;
    Node *r = nullptr;
    que->push(head);
    while(!que->empty()){
        head = que->front();
        que->pop();
        l = head->left;
        r = head->right;
        if( (leaf&&(l||r))//条件二
        ||(!l&&r)){//条件一
            return false;
        }
        if(l) que->push(l);
        if(r) que->push(r);
        if(!l||!r) leaf = true;
    }
    return true;
}

//--------------------是否是平衡二叉树-----------------------
struct ReturnType{
    bool isBalanced;
    int height;
    ReturnType(bool isB, int hei):isBalanced(isB),height(hei){}

};

ReturnType* process(Node* x){
    //base case
    if(!x) return new ReturnType(true, 0);

    ReturnType leftData = *process(x->left);
    ReturnType rightData = *process(x->right);

    int height = max(leftData.height, rightData.height)+1;

    bool isBalanced = leftData.isBalanced&&rightData.isBalanced
            &&abs(leftData.height-rightData.height)<2;
    ReturnType *ans = new ReturnType(isBalanced, height);

    return ans;

}
bool isBalanced(Node * head){
    return process(head)->isBalanced;
}


//---------------------是否搜索二叉树套路版---------------

struct ReturnData{
    bool isBST;
    int min;
    int max;
    ReturnData(bool is, int mi, int ma):isBST(is), min(mi), max(ma){}
};

ReturnData * process1(Node *x){
    if(!x){
        return nullptr;
    }
    ReturnData* leftData = process1(x->left);
    ReturnData* rightData = process1(x->right);

    int Min = x->value;
    int Max = x->value;
    if(leftData){
        Min = min(Min, leftData->min);
        Max = max(Max, leftData->max);
    }
    if(rightData){
        Min = min(Min, leftData->min);
        Max = max(Max, leftData->max);
    }

//    bool isBST = true;
//    if(leftData&&(!leftData->isBST || leftData->max>=x->value))
//        isBST = false;
//    if(rightData&&(!rightData->isBST || rightData->min<=x->value))
//        isBST = false;

    bool isBST = false;
    if(
            (leftData?(leftData->isBST&&leftData->max<x->value): true)
            &&(rightData?(leftData->isBST&&leftData->max<x->value):true)
            ){
        isBST = true;
    }

    return new ReturnData(isBST, Min, Max);
}

bool isBST1(Node * x){
    return process1(x)->isBST;
}

//---------------------是否为满二叉树----------------------
struct Info{
    int height;
    int nodes;
    Info(int h, int n){
        height = h;
        nodes = n;
    }

};

Info* processInfo(Node *x){
    if(!x) return new Info(0, 0);
    Info * leftData = processInfo(x->left);
    Info * rightData = processInfo(x->right);
    int height = max(leftData->height, rightData->height)+1;
    int nodes = leftData->nodes + rightData->nodes + 1;
    return new Info(height, nodes);
}

bool isF(Node *head){
    if(!head) return true;
    Info *data = processInfo(head);
    return data->nodes == (1<<data->height-1);//相当于2^l-1

}

Node* bT(){
    Node * head = new Node(8);
    head->left = new Node(6);
    head->right = new Node(10);
    head->left->left = new Node(4);
    head->left->right = new Node(7);
    head->left->left->left = new Node(1);
    head->left->left->right = new Node(5);
    head->right->left = new Node(9);
    head->right->right = new Node(11);
    return head;
}

void test(){
//    inOrderRecur(bT());//                          1
//    inOrderUnRecur(bT());//                        1
//    cout<<isBST(bT())<<endl;//                     1
//    cout<<isBSTUnRecur(bT())<<endl;//              1
//    cout<<isCBT(bT())<<endl;//                     1
//    cout<<isBalanced(bT())<<endl;//                1
//    cout<<isBST1(bT())<<endl;//                    1
//    cout<<isF(bT())<<endl;//                       0

}

int main(){
    test();
    return 0;
}

最低公共祖先：

#include<iostream>
#include<map>
#include<set>

using namespace std;
using namespace __gnu_cxx;

struct Node {
    int value;
    Node *left;
    Node *right;

    Node(int x) : value(x), left(nullptr), right(nullptr) {}
};

void process(Node *head, map<Node *, Node *> *fatherMap) {
    if (!head) return;
    fatherMap->insert(make_pair(head->left, head));
    fatherMap->insert(make_pair(head->right, head));
    process(head->left, fatherMap);
    process(head->right, fatherMap);
}

Node *lca(Node *head, Node *o1, Node *o2) {
    auto *fatherMap = new map<Node *, Node *>();
    fatherMap->insert(make_pair(head, head));
    process(head, fatherMap);
    auto *set1 = new set<Node *>();
    set1->insert(o1);
    Node *cur = o1;
    while (cur != fatherMap->find(cur)->second) {
        set1->insert(cur);
        cur = fatherMap->find(cur)->second;
    }
    set1->insert(head);
    cur = o2;
    while (cur != fatherMap->find(cur)->second) {
        if (set1->find(cur) != set1->end())
            return cur;
        else {
            cur = fatherMap->find(cur)->second;
        }
    }
    return head;
}


int main() {
    Node *head = new Node(8);
    head->left = new Node(6);
    head->right = new Node(10);
    head->left->left = new Node(4);
    Node *o1 = head->left->right = new Node(7);
    Node *o2 = head->left->left->left = new Node(1);
    head->left->left->right = new Node(5);
    head->right->left = new Node(9);
    head->right->right = new Node(11);
    cout<<lca(head, o1, o2)->value<<endl;
}

输出：6

左神原版本的代码用的是hash_ map，但是由与C++hash_map， 不支持自定义数据类型（虽然可以自定义hash模板），所以我只能用map了

在二叉树中找到一个节点的后继节点

后继节点，是中序遍历一个节点的的下一个节点

还是最开始的二叉树，它中序遍历的结果是1，4，5，6，7，8，9，10，11

那么节点4的后继节点就是5

在这里插入图片描述

二叉树的序列化和反序列化

在这里插入图片描述

微软面试题，折纸条

在这里插入图片描述

所以要从上到下打印所有折痕的方向，就是这颗二叉树中序遍历

这颗树的特点是，头节点是凹折痕，每个左子树的头节点都是凹折痕，每个右子树头节点都是凸折痕

blackcatkiller
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
二叉树相关练习题（C++）
DjangoBUAA的博客
04-09 4861
一、二叉树 1、用递归方法实现二叉树的先序、中序、后序遍历 class TreeToSequence { public:           void preOrder(TreeNode* root,vectorint> &pre) {          if (!root)              return;          pr
【题目】二叉树题目总结
m0_51064412的博客
11-27 1506
文章目录一. 前序遍历类二. 中序遍历类三. 后序遍历类四. 层序遍历类1. 二叉树的层序遍历五. 其他类型题目1. 二叉树的最近公共祖先 一. 前序遍历类 二. 中序遍历类 三. 后序遍历类 四. 层序遍历类 1. 二叉树的层序遍历 题目连接 题目描述： 给你一个二叉树，请你返回其按层序遍历得到的节点值。（即逐层地，从左到右访问所有节点）。 解题思路： 借助队列拿出每一层节点的同时按照从左到右的顺序存入下一层的所有节点，其核心代码下面这条，确保拿出当前层的节点： for(size_t i = q.s
c++逆天改命进阶--二叉树练习题
btzxlin的博客
05-19 299
1.根据二叉树创建字符串 606. 根据二叉树创建字符串 - 力扣（LeetCode） class Solution { public: void _tree2str(TreeNode* root, string& str) { if(root==nullptr)//为空直接返回 { return; } if(root->left&& root->right)//左右
二叉树各种类型汇总
上善若泪
06-26 8357
文章目录1 树类型1.1 二叉树1.2 完全二叉树1.3 满二叉树1.4 二叉搜索树（二叉排序树、二叉查找树）1.5 平衡二叉树1.6 红黑树1.6.1 红黑树概念1.6.2 红黑树和AVL树区别1.7 B树类型1.7.1 B树1.7.2 B-树1.7.3 B+树1.7.4 B*树 学习了树的结构类型后，主要对各种树类型进行汇总总结 1 树类型 树中的基本概念：https://jingzh.blog.csdn.net/article/details/107128291 树类型概述： 二叉树，完全二叉树，满二
数据结构——常见二叉树的分类（完全二叉树、满二叉树、平衡二叉树、二叉搜索树、红黑树）
weixin_45338443的博客
06-25 3227
二叉树的定义、特点和常见分类
基础二叉树算法的C++实现
最新发布
11-10
基础二叉树算法的C++实现
二叉树各种遍历算法的C++实现
05-19
在这个主题中，我们将深入探讨二叉树的三种主要遍历方法：前序遍历、中序遍历和后序遍历，以及它们在C++中的实现方式。 1. **前序遍历**：前序遍历的顺序是根节点 -> 左子树 -> 右子树。在C++中，递归实现可以如下...
[C++算法入门]-二叉树打印练习题
09-26
该资源提供了入门级别的C++算法练习，旨在帮助读者熟悉二叉树的打印操作和相关算法。文档中包含了一系列的练习题，涵盖了二叉树的构建、遍历和打印等方面。 通过完成这些练习，读者将能够掌握二叉树的基本概念和...
C++使用递归和非递归算法实现的二叉树叶子节点个数计算方法
08-30
C++使用递归和非递归算法实现的二叉树叶子节点个数计算方法 本文主要介绍了C++使用递归和非递归算法实现的二叉树叶子节点个数计算方法，涉及C++二叉树的定义、遍历、统计相关操作技巧。 一、二叉树的定义 在...
C++基于递归和非递归算法求二叉树镜像的方法
08-30
本文主要介绍了C++语言中基于递归和非递归算法求二叉树镜像的方法。二叉树镜像是指将二叉树的左右子树交换，使其成为镜像的过程。本文将详细讲述递归和非递归算法的实现与使用技巧，并提供了实例代码供读者参考。 ...
二叉树的性质和种类
qq_41936224的博客
08-23 3417
目录一、二叉树1、满二叉树2、完全二叉树3、二叉排序树4、平衡二叉树5、红黑树 一、二叉树 二叉树(逻辑结构)：二叉树是n(n>=0)个结点的有限集合 1、n=0时，二叉树为空 2、n>0时，由根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树也分别是一颗二叉树 注意：二叉树是有左右之分的 二叉树的五种基本形态 1、满二叉树 满二叉树定义：一棵高度为h，并且有(2^h)−1个结点的二叉树为满二叉树。 特点：所有的叶子结点都在最后一层 性质：对于编号为 i 的结点，若存在，其双亲
数据结构——普通二叉树
weixin_30483013的博客
01-18 155
　　1. 普通二叉树 1.1 二叉树性质 关于二叉树的深度和高度涉及到结点的层数，有的教材规定根结点在第0层，有的则规定根结点在第1层。 以《数据结构-C语言版》(严蔚敏,吴伟民版)的为准：高度和深度是同一个概念，根节点在第1层，树的高度是看一共有几层。 高度为h的完全二叉树，最多有2^n-1个节点，第k层最多有2^(k-1)个节点。 含有n个节点的完全二叉树，高度为（lo...
[数据结构]——二叉树(二叉树的分类和二叉树的遍历)
攻城狮Jana的学习博客
03-17 591
文章目录一、二叉树的分类1、满二叉树2、完全二叉树3、平衡二叉树一、二叉树的分类 一、二叉树的分类 1、满二叉树 最后一层节点无任何子节点，其余每一层上的所有结点都有两个子结点的二叉树。 2、完全二叉树 一棵深度为h的树，前h-1层为满二叉树，第h层的结点从左到右是连续的。 上图为一颗三层的平衡二叉树，前两层为满二叉树，最后一层从左到右的结点是连续的。 下面我们再举一个完全二叉树的反例： 3、平衡二叉树 一棵深度为h的二叉树，任意节点的子树的高度差都小于等于1。 再举一个平衡二叉树的反例： 一、.
C++笔试编程题5:种树
Coding
08-29 2560
2019拼多多笔试编程题 种树 小多想在美化一下自己的庄园。他的庄园毗邻一条小河，他希望在河边种一排树，共 M 棵。小多采购了 N 个品种的树，每个品种的数量是 Ai (树的总数量恰好为 M)。但是他希望任意两棵相邻的树不是同一品种的。小多请你帮忙设计一种满足要求的种树方案。 输入第一行包含一个正整数 N，表示树的品种数量。 第二行包含 N 个正整数，第 i (1 <= i <= ...
一句话弄懂常见二叉树类型
热门推荐
许佳佳的博客
11-22 1万+
满二叉树除最后一层无任何子节点外，每一层上的所有结点都有两个子结点二叉树。 完全二叉树一棵二叉树至多只有最下面的一层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。 平衡二叉树它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树 二叉搜索树它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不
[C++算法] - 二叉树《21道常见的面试题》
Snoopy_Dream
10-21 844
自己动手写代码，记录中间出现的错误。 这个网址不错https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E6%A0%91.md 目录 中序遍历！ 先序遍历 后序遍历 按层遍历 不分行打印（deque） 分行打印（queue） Z字遍历（两个栈） Mo...
二叉树分类
qq_41907471的博客
11-16 1034
#二叉树分类 满二叉树： 对于国内的满二叉树： 从图形形态上看，满二叉树外观上是一个三角形。 从数学上看，满二叉树的各个层的结点数形成一个首项为1，公比为2的等比数列。 对于国外的满二叉树 满二叉树的结点要么是叶子结点，度为0，要么是度为2的结点，不存在度为1的结点。 完全二叉树：设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集...
二叉树类型笔试面试题大总结（含代码）
844604778
10-15 289
一、二叉树的遍历-前序、中序、后序以及层次遍历（递归与非递归） 参考另外一篇笔记《二叉树的遍历-递归与非递归 -海子 - 博客园》。 二、重建二叉树，依据前序遍历结果和中序遍历结果 《剑指Offer》面试题6. 思想：递归 代码： // 《剑指Offer——名企面试官精讲典型编程题》代码 // 著作权所有者：何海涛 struct BinaryTreeNode { i...
关于树的宽度思路分析 和完整代码（C++）
qq_40901762的博客
06-11 603
                                                                                            题目利用先序递归遍历算法创建二叉树并计算该二叉树的宽度。先序递归遍历建立二叉树的方法为：按照先序递归遍历的思想将对二叉树结点的抽象访问具体化为根据接收的数据决定是否产生该结点从而实现创建该二叉树的二叉链表存储结构。约...
数据结构实验61
08-08
实验要求学生用C++面向对象编程实现二叉树类，并能处理多种数据输入方式。实验中涉及的具体操作有：遍历序列的打印、结点层次和数量的计算、叶子结点和度为2的结点计数、找父节点、兄弟结点和子结点、层次查询、顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值