树 超基础二叉树知识

最新推荐文章于 2024-02-28 18:33:17 发布
最新推荐文章于 2024-02-28 18:33:17 发布
阅读量779 收藏 15
点赞数
分类专栏： # 树 文章标签： 二叉树 数据结构 算法 树堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CrazyMooo/article/details/106083457
版权

编写一个程序，实现二叉树的基本运算，具体要求如下：

  1. 括号表示法读入数据
  2. 括号表示法输出该树
  3. 输入一个结点的值，输出该结点的左，右孩子的值（要能测试错误数据）
  4. 输出该二叉树的高度
  5. 输出该二叉树结点的个数
  6. 输出该二叉树双分支结点的个数
  7. 输出该二叉树单分支结点的个数
  8. 输出该二叉树叶子结点的个数
  9. 输出该二叉树的宽度（宽度为每层结点数的最大值）
  10. 任意给定该二叉树的两个结点，输出它们的最近的公共祖先
  11. 销毁该二叉树

运行结果：



-1.变量定义

#include <bits/stdc++.h>
using namespace std;
const int MaxSize = 50;

typedef char ElementType; //typedef用来给数据类型char起别名(ElementType)
typedef struct bitnode
{
    ElementType data;
    struct bitnode *left, *right;
} bitnode, *bitree; //bitree为指向bitnode这种自定义数据的指针

0. 括号表示法读入数据

//----------------------------------------------------
//根据嵌套括号表示法的字符串生成链式存储的二叉树
void CreateTree(bitree &b, char str[]){
    char ch;
    bitree stack[MaxSize], p;   //stack[MaxSize]为指针数组，其每一个元素都为指向bitnode这种结构的指针，p为临时指针
    int top = -1, k = 0, j = 0; //top为栈顶指针、k决定谁是左、右孩子、j为str指针

    while ((ch = str[j++]) != '\0'){
        switch (ch)
        {
        case '(':
            top++;
            stack[top] = p; //根结点入栈
            k = 1;          //1为左孩子
            break;
        case ',':
            k = 2; //2为右孩子
            break;
        case ')':
            top--; //根结点出栈
            break;
        default:
            p = (bitree)malloc(sizeof(bitnode));
            p->data = ch;
            p->left = p->right = NULL;

            switch (k)
            {
            case 1:
                stack[top]->left = p; //根结点的左孩子
                break;
            case 2:
                stack[top]->right = p; //根结点的右孩子
                break;
            default:   // k 初始化为0
                b = p; //树为空时
                break;
            }
        }
    }
}

1. 括号表示法输出该树

//----------------------------------------------------
// 1，括号表示法输出该树。
void PrinTree(bitree b){
    if (b){
        cout << b->data; //访问根结点
        if (b->left != NULL || b->right != NULL){
            cout << "("; // 先输出左括号
            PrinTree(b->left); //递归处理左子树
            if (b->right != NULL) //不判断直接输出会导致输出结果不符
                cout << ",";
            PrinTree(b->right); //递归处理右子树
            cout << ")"; //输出右括号
        }
    }
}

2. 输入一个结点的值，输出该结点的左，右孩子的值

//----------------------------------------------------
// 2，输入一个结点的值，输出该结点的左，右孩子的值。（要能测试错误数据）
bool getValue(bitree b, ElementType value){
    if (b == NULL)//找不到就false
        return false;
    if (b->data == value){//找到输出
        if (b->left)
            cout << "左孩子结点：" << b->left->data;
        else
            cout << " 无左孩子结点";
        if (b->right)
            cout << " 右孩子结点：" << b->right->data;
        else
            cout << " 无右孩子结点";
        cout << "\n";
        return true;//标记找到了
    }
    //如果找到了就不用再递归了。而且继续递归会导致最后可能return false
    if(getValue(b->left, value))return true;
    if(getValue(b->right, value))return true;
}

3. 输出该二叉树的高度

//----------------------------------------------------
//3，输出该二叉树的高度。
int getDeep(bitree b){
    if(b==NULL)return 0;
    return max(getDeep(b->left),getDeep(b->right))+1;//左子树右子树哪边深
}

4. 输出该二叉树结点的个数

//----------------------------------------------------
// 4，输出该二叉树结点的个数。
int getNums(bitree b){
    if(b==NULL)return 0;
    return getNums(b->left)+getNums(b->right)+1;//左子树+右子树+1
}

5. 输出该二叉树双分支结点的个数

//----------------------------------------------------
// 5，输出该二叉树双分支结点的个数。
int get2BranchNums(bitree b){
    if (b == NULL||(b->left==NULL&&b->right==NULL))//由于是双分支结点，左右儿子均不能为NULL
        return 0;
    if(b->left&&b->right)//是双分支结点
        return 1+get2BranchNums(b->left)+get2BranchNums(b->right);//继续递归
    return get2BranchNums(b->left)+get2BranchNums(b->right);//递归
}

6. 输出该二叉树单分支结点的个数

//----------------------------------------------------
// 6，输出该二叉树单分支结点的个数。
int get1BranchNums(bitree b){
    if (b == NULL||(b->left==NULL&&b->right==NULL))//题目要求是单分治结点
        return 0;
    if((b->left||b->right)&&!(b->left&&b->right))//找到了
        return 1+get1BranchNums(b->left)+get1BranchNums(b->right);
    return get1BranchNums(b->left)+get1BranchNums(b->right);
}

7. 输出该二叉树叶子结点的个数

//----------------------------------------------------
// 7，输出该二叉树叶子结点的个数。
int getLeafNodes(bitree b){
    if(b==NULL)return 0;
    if(b->right==NULL&&b->left==NULL)return 1;//叶子节点没有孩子
    return getLeafNodes(b->left)+getLeafNodes(b->right);//左子树叶子结点个数+右子树叶子节点个数
}

8. 输出该二叉树的宽度（宽度为每层结点数的最大值）

//----------------------------------------------------
// 8，输出该二叉树的宽度。（宽度为每层结点数的最大值）
int getWidth(bitree b){//需要用队列
    int tmpWidth=0,maxWidth=1;
    if(b==NULL)return 0;
    queue<bitnode*> q;
    q.push(b);//入队
    while(q.size()){
        tmpWidth = q.size();
        //若每一层的宽度大于maxWidth，则重新赋值
        maxWidth = max(tmpWidth,maxWidth);//更新maxWidth
        //注意这里循环的次数是width,出队的仅仅是每一层的元素
        for (int i = 0; i < tmpWidth; i++) {
            bitnode *nodeTemp = q.front();
            q.pop();
            //左右子树不为空则入队
            if (nodeTemp->left != NULL) {
                q.push(nodeTemp->left);
            }
            if(nodeTemp->right != NULL) {
                q.push(nodeTemp->right);
            }
        }
    }
    return maxWidth;//返回求得的最大宽度
}

9. 任意给定该二叉树的两个结点，输出它们的最近的公共祖先

//----------------------------------------------------
// 9，任意给定该二叉树的两个结点，输出它们的最近的公共祖先。
bitnode* findLCA(bitree root, ElementType n1, ElementType n2){
    if (root == NULL) return NULL;
    // 此处默认输入数据合法！！！
    if (root->data == n1 || root->data == n2)
        return root;
    //递归寻找
    bitnode* left_lca  = findLCA(root->left, n1, n2);
    bitnode* right_lca = findLCA(root->right, n1, n2);
    // 如果两个结果都非NULL ，则两个点分别在左右儿子树上
    if (left_lca && right_lca)  return root;
    // 否则检查左子树或右子树是否为最近公共祖先
    return (left_lca != NULL)? left_lca: right_lca;
}

10. 销毁该二叉树

//----------------------------------------------------
//10，销毁该二叉树
bitree FreeTree(bitree b){
    if (b != NULL){
        FreeTree(b->left);  //递归释放左子树
        FreeTree(b->right); //递归释放右子树
        free(b);  //释放根结点
        b = NULL; //释放指向根结点的指针
    }
    return b; //return NULL;
}
  1. 主函数
int main(){
    // char str[] = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
    char str[] = "A(B(D(,G),),C(E,F))";
    bitree root = NULL; //不要忘记初始化
    ElementType tmp,tmp1,tmp2;
    int t1,t2;
    CreateTree(root, str);

    cout << "字符串：" << str << "\n";
    cout << "1，括号表示法输出该树：";
    PrinTree(root);
    cout << "\n";

    cout << "2，输入一个结点的值，输出该结点的左，右孩子的值\n";
    cin >> tmp;
    if (!getValue(root, tmp))
        cout << "查找失败！\n";
    cout<<"3，输出该二叉树的高度:  ";
    cout<<getDeep(root)<<"\n";

    cout<<"4，输出该二叉树结点的个数: ";
    cout<<getNums(root)<<"\n";

    cout<<"5，输出该二叉树双分支结点的个数: ";
    cout<<get2BranchNums(root)<<"\n";

    cout<<"6，输出该二叉树单分支结点的个数: ";
    cout<<get1BranchNums(root)<<"\n";

    cout<<"7，输出该二叉树叶子结点的个数: ";
    cout<<getLeafNodes(root)<<"\n";

    cout<<"8，输出该二叉树的宽度: ";
    cout<<getWidth(root)<<"\n";

    cout<<"9，给定该二叉树的两个结点，输出它们的最近的公共祖先: \n";
    cout<<"请输入您所需要查找的两个结点：";
    cin>>tmp1>>tmp2;
    bitnode* tmpnode = findLCA(root,tmp1,tmp2);
    if(tmpnode==NULL){
        cout<<"结点: "<<tmp1<<" 和 "<<tmp2<<" 没有公共结点\n";
    }else{
        cout<<"结点: "<<tmp1<<" 和 "<<tmp2<<" 的最近公共结点为："<<tmpnode->data<<"\n";
    }

    cout<<"10，销毁该二叉树\n";
    root = FreeTree(root);
    if (root == NULL)
        cout << "二叉树销毁成功" << "\n";

    return 0;
}

完整代码

#include <bits/stdc++.h>
using namespace std;
const int MaxSize = 50;

typedef char ElementType; //typedef用来给数据类型char起别名(ElementType)
typedef struct bitnode
{
    ElementType data;
    struct bitnode *left, *right;
} bitnode, *bitree; //bitree为指向bitnode这种自定义数据的指针

//----------------------------------------------------
//根据嵌套括号表示法的字符串生成链式存储的二叉树
void CreateTree(bitree &b, char str[]){
    char ch;
    bitree stack[MaxSize], p;   //stack[MaxSize]为指针数组，其每一个元素都为指向bitnode这种结构的指针，p为临时指针
    int top = -1, k = 0, j = 0; //top为栈顶指针、k决定谁是左、右孩子、j为str指针

    while ((ch = str[j++]) != '\0'){
        switch (ch)
        {
        case '(':
            top++;
            stack[top] = p; //根结点入栈
            k = 1;          //1为左孩子
            break;
        case ',':
            k = 2; //2为右孩子
            break;
        case ')':
            top--; //根结点出栈
            break;
        default:
            p = (bitree)malloc(sizeof(bitnode));
            p->data = ch;
            p->left = p->right = NULL;

            switch (k)
            {
            case 1:
                stack[top]->left = p; //根结点的左孩子
                break;
            case 2:
                stack[top]->right = p; //根结点的右孩子
                break;
            default:   // k 初始化为0
                b = p; //树为空时
                break;
            }
        }
    }
}

//----------------------------------------------------
// 1，括号表示法输出该树。
void PrinTree(bitree b){
    if (b){
        cout << b->data; //访问根结点
        if (b->left != NULL || b->right != NULL){
            cout << "("; // 先输出左括号
            PrinTree(b->left); //递归处理左子树
            if (b->right != NULL) //不判断直接输出会导致输出结果不符
                cout << ",";
            PrinTree(b->right); //递归处理右子树
            cout << ")"; //输出右括号
        }
    }
}

//----------------------------------------------------
// 2，输入一个结点的值，输出该结点的左，右孩子的值。（要能测试错误数据）
bool getValue(bitree b, ElementType value){
    if (b == NULL)//找不到就false
        return false;
    if (b->data == value){//找到输出
        if (b->left)
            cout << "左孩子结点：" << b->left->data;
        else
            cout << " 无左孩子结点";
        if (b->right)
            cout << " 右孩子结点：" << b->right->data;
        else
            cout << " 无右孩子结点";
        cout << "\n";
        return true;//标记找到了
    }
    //如果找到了就不用再递归了。而且继续递归会导致最后可能return false
    if(getValue(b->left, value))return true;
    if(getValue(b->right, value))return true;
}
//----------------------------------------------------
//3，输出该二叉树的高度。
int getDeep(bitree b){
    if(b==NULL)return 0;
    return max(getDeep(b->left),getDeep(b->right))+1;//左子树右子树哪边深
}
//----------------------------------------------------
// 4，输出该二叉树结点的个数。
int getNums(bitree b){
    if(b==NULL)return 0;
    return getNums(b->left)+getNums(b->right)+1;//左子树+右子树+1
}
//----------------------------------------------------
// 5，输出该二叉树双分支结点的个数。
int get2BranchNums(bitree b){
    if (b == NULL||(b->left==NULL&&b->right==NULL))//由于是双分支结点，左右儿子均不能为NULL
        return 0;
    if(b->left&&b->right)//是双分支结点
        return 1+get2BranchNums(b->left)+get2BranchNums(b->right);//继续递归
    return get2BranchNums(b->left)+get2BranchNums(b->right);//递归
}
//----------------------------------------------------
// 6，输出该二叉树单分支结点的个数。
int get1BranchNums(bitree b){
    if (b == NULL||(b->left==NULL&&b->right==NULL))//题目要求是单分治结点
        return 0;
    if((b->left||b->right)&&!(b->left&&b->right))//找到了
        return 1+get1BranchNums(b->left)+get1BranchNums(b->right);
    return get1BranchNums(b->left)+get1BranchNums(b->right);
}
//----------------------------------------------------
// 7，输出该二叉树叶子结点的个数。
int getLeafNodes(bitree b){
    if(b==NULL)return 0;
    if(b->right==NULL&&b->left==NULL)return 1;//叶子节点没有孩子
    return getLeafNodes(b->left)+getLeafNodes(b->right);//左子树叶子结点个数+右子树叶子节点个数
}
//----------------------------------------------------
// 8，输出该二叉树的宽度。（宽度为每层结点数的最大值）
int getWidth(bitree b){//需要用队列
    int tmpWidth=0,maxWidth=1;
    if(b==NULL)return 0;
    queue<bitnode*> q;
    q.push(b);//入队
    while(q.size()){
        tmpWidth = q.size();
        //若每一层的宽度大于maxWidth，则重新赋值
        maxWidth = max(tmpWidth,maxWidth);//更新maxWidth
        //注意这里循环的次数是width,出队的仅仅是每一层的元素
        for (int i = 0; i < tmpWidth; i++) {
            bitnode *nodeTemp = q.front();
            q.pop();
            //左右子树不为空则入队
            if (nodeTemp->left != NULL) {
                q.push(nodeTemp->left);
            }
            if(nodeTemp->right != NULL) {
                q.push(nodeTemp->right);
            }
        }
    }
    return maxWidth;//返回求得的最大宽度
}
//----------------------------------------------------
// 9，任意给定该二叉树的两个结点，输出它们的最近的公共祖先。
bitnode* findLCA(bitree root, ElementType n1, ElementType n2){
    if (root == NULL) return NULL;
    // 此处默认输入数据合法！！！
    if (root->data == n1 || root->data == n2)
        return root;
    //递归寻找
    bitnode* left_lca  = findLCA(root->left, n1, n2);
    bitnode* right_lca = findLCA(root->right, n1, n2);
    // 如果两个结果都非NULL ，则两个点分别在左右儿子树上
    if (left_lca && right_lca)  return root;
    // 否则检查左子树或右子树是否为最近公共祖先
    return (left_lca != NULL)? left_lca: right_lca;
}

//----------------------------------------------------
//10，销毁该二叉树
bitree FreeTree(bitree b){
    if (b != NULL){
        FreeTree(b->left);  //递归释放左子树
        FreeTree(b->right); //递归释放右子树
        free(b);  //释放根结点
        b = NULL; //释放指向根结点的指针
    }
    return b; //return NULL;
}

int main(){
    // char str[] = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
    char str[] = "A(B(D(,G),),C(E,F))";
    bitree root = NULL; //不要忘记初始化
    ElementType tmp,tmp1,tmp2;
    int t1,t2;
    CreateTree(root, str);

    cout << "字符串：" << str << "\n";
    cout << "1，括号表示法输出该树：";
    PrinTree(root);
    cout << "\n";

    cout << "2，输入一个结点的值，输出该结点的左，右孩子的值\n";
    cin >> tmp;
    if (!getValue(root, tmp))
        cout << "查找失败！\n";
    cout<<"3，输出该二叉树的高度:  ";
    cout<<getDeep(root)<<"\n";

    cout<<"4，输出该二叉树结点的个数: ";
    cout<<getNums(root)<<"\n";

    cout<<"5，输出该二叉树双分支结点的个数: ";
    cout<<get2BranchNums(root)<<"\n";

    cout<<"6，输出该二叉树单分支结点的个数: ";
    cout<<get1BranchNums(root)<<"\n";

    cout<<"7，输出该二叉树叶子结点的个数: ";
    cout<<getLeafNodes(root)<<"\n";

    cout<<"8，输出该二叉树的宽度: ";
    cout<<getWidth(root)<<"\n";

    cout<<"9，给定该二叉树的两个结点，输出它们的最近的公共祖先: \n";
    cout<<"请输入您所需要查找的两个结点：";
    cin>>tmp1>>tmp2;
    bitnode* tmpnode = findLCA(root,tmp1,tmp2);
    if(tmpnode==NULL){
        cout<<"结点: "<<tmp1<<" 和 "<<tmp2<<" 没有公共结点\n";
    }else{
        cout<<"结点: "<<tmp1<<" 和 "<<tmp2<<" 的最近公共结点为："<<tmpnode->data<<"\n";
    }

    cout<<"10，销毁该二叉树\n";
    root = FreeTree(root);
    if (root == NULL)
        cout << "二叉树销毁成功" << "\n";

    return 0;
}

代码思路，编辑格式不易，大家觉得还可以可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，https://motongxue.gitee.io

Motongxue
关注
  • 0
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面试常问基础知识总结（超经典）
07-02
2. **数据结构与算法**：面试中常考的数据结构有数组、链表、栈、队列、堆、树（二叉树、平衡树如AVL和红黑树）、图等，以及相关的排序算法（冒泡、选择、插入、快速、归并、堆排序）和查找算法（顺序、二分、哈希）...
算法面试基础知识.zip
02-20
这包括数组、链表、栈、队列、哈希表、树（二叉树、红黑树、B树等）、图、堆、排序算法（快速排序、归并排序、堆排序等）、查找算法（二分查找、哈希查找）等。熟练掌握这些数据结构和算法的实现、时间和空间复杂度...
括号表示法字符串构造二叉树_[二叉树面试算法]-(七) 重构二叉树-相关题型总结(4题)...
weixin_39929153的博客
11-22 401
从前序与中序遍历序列构造二叉树_leetcode105 从中序与后序遍历序列构造二叉树_leetcode106 根据前序和后序遍历构造二叉树_leetcode889 二叉树的序列化与反序列化_leetcode297 1.从前序与中序遍历序列构造二叉树思路:第一步： 前序遍历的第一个节点，即为根节点。 第二步： 由根节点，可以在中序遍历中，找到左子树对应的长度。 第三步： 根据左子树的长度， 可以在...
将字符串的内容转换为一棵二叉树
陌意随影的博客
10-23 5213
问题：从控制台中输入一串“A(B(C,D(,E)),F(G,H(M,N(,Q))))“，将其转化建立一棵二叉树。 从这个问题我们可以知道，首先我们需要一个将这个字符串所表示的二叉树用代码的方式建立起来。我们先来看看这个字符串所表示的二叉树： 下面我们开始分析这个二叉树建立的思路： （1）读取第一个字符建立第一个节点即为根节点； （2）继续读取下一个字符，如果遇到“（”，那么当前节点为父节点，并且...
找二叉树中给定元素的的左孩子结点_数据结构：二叉树的基础概念和算法
weixin_39887546的博客
11-20 1082
​树是由一个根结点和若干棵子树构成。二叉树：每个结点最多两棵子树，是有序的。满二叉树：二叉树中，所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上。完全二叉树：在满二叉树中，从最后一个结点开始，连续去掉任意个结点，即是一棵完全二叉树。二叉树的遍历：前序遍历（根左右），中序遍历（左根右），后序遍历（左右根），层序遍历。熟练掌握二叉树的三种遍历递归和非递归的6种实现方法。宽度优先遍历：对二叉树...
7-4 输出一棵给定二叉树的所有叶子节点
wuwuhuai的博客
03-06 6260
//输出一棵给定二叉树的所有叶子节点 #include "btree.cpp" void DispLeaf(BTNode *b) { if (b!=NULL) { if (b-&gt;lchild==NULL &amp;&amp; b-&gt;rchild==NULL) printf("%c ",b-&gt;data); //访问叶子节点 DispLeaf(b-&gt;lch...
数据结构——二叉树的基本操作（二）
yxl_d的博客
10-29 2503
一、实验目的及要求 1.理解二叉树的基本概念和特点 2.掌握二叉树的链式存储结构 3.掌握二叉树的基本操作 4.掌握二叉树遍历操作 二、实验内容（或实验原理、实验拓扑） 1.实现二叉树的如下操作，先序遍历、中序遍历和后序遍历的递归算法，二叉树如下图所示。(采用二叉链存储结构实现) (1)采用括号表示法，构建如下二叉树，并输出二叉树b； (2)采用递归算法，输出二叉树的先序序列；（参考课本212页代...
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
在IT领域，数据结构是计算机科学的基础，而树和二叉树是其中极其重要的概念。西南科技大学（SWUST）的在线编程平台（OJ）提供了关于这些主题的编程题目，帮助学生深入理解和应用这些知识。以下是对这些题目涉及知识...
超详细的数据结构知识点-个人笔记
05-07
这篇超详细的“数据结构知识点-个人笔记”涵盖了数据结构的基础理论和实际应用，是初学者入门的理想资源。 笔记首先介绍了数据结构的基本概念，包括数组、链表、栈和队列等基本类型。数组是最基础的数据结构，它是...
(完整word)整理好的超完整计算机二级公共基础知识.doc
11-15
在准备计算机二级公共基础知识考试时，考生应重点掌握算法的时间复杂度和空间复杂度计算，理解数据结构的逻辑结构和存储结构，熟悉常见的数据结构如栈、队列、链表、树和图，并掌握相应的操作，如栈的入栈和出栈、...
树的括号表示法
最新发布
m0_60343477的博客
02-28 1092
发现，所有的括号都是配对出现的，且’(‘其配对的是最近的’）’。每次当遇到’(‘的时候，可以把新的问题具体成”构建一棵小树“（发现和最开始的问题是一个内在逻辑）。对于S字符串分析，S=A(B(,D(G,)),C(E,F(H,)))。遍历到B后面的’(‘的时候，问题变成构建B(,D(G,)),C(E,F(H,))这棵树，然后B挂在A身上。最开始的问题是构建A(B(,D(G,)),C(E,F(H,))) 这棵树。遍历到D后面的’(‘的时候，问题变成构建D(G,)这颗树。1.用一个类表示树的节点。
用括号法递归建立二叉树
zhao2018的博客
06-21 4986
描述如果用大写字母标识二叉树节点，则一棵二叉树可以用以下字母序列建立，#表示空节点。试写一个递归算法，有这种形式的字符序列，建立相应的二叉树的二叉链表存储结构，并按层次遍历输出。如一棵二叉树可表示为：A(B(#,D),C(E(#,F),#)) 输入按题中要求，用括号法输入二叉树序列，#表示空节点 输出按层次遍历建立好的二叉树并输出 输入样例A(B(#,D),C(E(#,F),#)) 输出样例ABC...
输出二叉树的叶子结点、高度及重建二叉树
my_miuye的博客
06-01 2614
1.输出二叉树中的叶子结点   思路：在二叉树的遍历算法中增加检测结点的“左右子树是否都为空” void PreorderTraversal( BinTree BT ) { if( BT ) { if( !BT->Left && !BT->Right) //检测左右子树是否都为空 printf("%d ", BT-...
Python实现数据结构之二叉树(3)
菜鸡的博客
05-12 236
定义及相关术语 定义- 子树不相交； - 抛开根节点，每个节点有且仅有一个父节点； - 一棵N个节点的树有N-1条边。 相关术语- 节点的度：一个节点含有的子树的个数称为该节点的度； - 树的度：一颗树中，最大的节点的度称为树的度； - 叶节点或终端节点：度为零的节点； - 父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； - 子节点：一个节点含有的子树的根节点称为该节点的子节点； - 兄弟节点：具有相同父节点的节点互相称为兄弟节点； - 节点的层次：从根节点开始定义起，根为第一层，.
找二叉树中给定元素的的左孩子结点_[第33期] 树，二叉树， 二叉搜索树
weixin_39598568的博客
11-20 449
关注 前端e进阶，回复“加群”加入我们一起学习，天天进步背景树， 是一种常见的数据结构， 有很多的应用场景， 也是面试中的常客。比如：树的遍历， 分层打印， 平摊的数据转成树， 等等。这就需要我们对树这种数据结构有个基础的认识，今天我们就再回顾一下这种数据结构。正文今天的内容主要包括：树二叉树二叉搜索树题目实战树讲树之前， 我们先回顾下链表。[第28期] 回顾一下常见的链表操作实际上...
面试中常见二叉树的各种操作
橘嘉禾
03-12 749
本篇针对面试中常见的二叉树操作作个总结： 前序遍历，中序遍历，后序遍历； 1.1 前序遍历 对于当前结点，先输出该结点，然后输出它的左孩子，最后输出它的右孩子。以上图为例，递归的过程如下： 输出 1，接着左孩子； 输出 2，接着左孩子； 输出 4，左孩子为空，再接着右孩子； 输出 6，左孩子为空，再接着右孩子； 输出 7，左右孩子都为空，此时 2 的左子树全部输出，2 的右子树为空，...
【数据结构】树
weixin_34081595的博客
04-20 275
概念 （百度百科）树状图是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 从概念去理解，之所以叫“树”是因为形状像树，并非对“真实树”的模仿，所以不像链表结构一样可以参考现实中链状事物的构造。例如“真实树”有树干，而树状图是没有树干概念的，那么树状图又有什么特点呢，...
作业2 链式存储结构及其操作
sususuyesylvia的博客
12-18 1263
作业2 2-1 设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是：(1分) t->next=h->next; h=t;h=t; t->next=h;t->next=h; h=t;h=t; t->next=h->next 2-2 不带表头附加结点的单链表为空的判断条件是头指针head满足条件（）。 (1分) head!
计算机二级公共基础知识：算法复杂度与数据结构要点
经过对部分考生调查和近年真题的总结分析，计算机二级公共基础知识的笔试部分经常考查算法复杂度、数据结构的概念、栈、...通过总结整理好的超完整计算机二级公共基础知识文档中的相关知识点，读者可以更好地准备考试。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值