数据结构与算法6:树的表示法（二叉树的遍历）

最新推荐文章于 2022-08-23 19:02:30 发布
最新推荐文章于 2022-08-23 19:02:30 发布
阅读量260 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42278523/article/details/107599935
版权

树的遍历，是指依照一定的规律不反复地訪问（或取出节点中的信息，或对节点做其它的处理）树中的每个节点，遍历是将非线性的树状结构按一定规律转化为线性结构。

1. 多叉树遍历

多叉树遍历分为深度优先遍历和广度优先遍历两类。树孩子表示法比较容易遍历。
图形演示：visualgo DFS BFS

1.1 深度优先遍历(DFS:Depth First Search)

在这里插入图片描述

深度优先遍历：从根节点开始先沿着树的一个枝遍历到叶子节点，再遍历其他的枝。深度优先遍历又分为先序遍历和后序遍历。
在这里插入图片描述

1.1.1 先序遍历

树中父节点先于子节点访问
上图树的先序遍历结果：A → B → D → G → H → I → C → E → J → F
通常先序遍历实现分两种方式：递归方式和非递归方式(栈方式)。
参考代码

递归深度优先遍历：先序遍历

void RecurtionPreDFS(int root,Node* nodes){
    printf("%c ",nodes[root].data);
    for(int i= 0;i<nodes[root].children.size();++i){
        int post = nodes[root].children[i];
        RecurtionPreDFS(post,nodes);
    }
}

非递归深度优先遍历：先序遍历

void PreDFS(int root,Node* nodes){
    stack<int> s;
    s.push(root);
    while(!s.empty()){
        int now = s.top();
        s.pop();
        printf("%c ",nodes[now].data);// 出栈访问
        for(int i= nodes[now].children.size()-1; i>=0;--i){
            int post = nodes[now].children[i];
            s.push(post);
        }
    }
}

迭代是横向思维，递归是纵向思维
在这里插入图片描述
在这里插入图片描述

1.1.2 后序遍历

树中子节点先于父节点访问
上图树的后序遍历结果：G → H → I → D → B → J → E → F → C → A
递归深度优先遍历：后序遍历

void RecurtionPostDFS(int root,Node* nodes){
    for(int i= 0;i<nodes[root].children.size();++i){
        int post = nodes[root].children[i];
        RecurtionPostDFS(post,nodes);
    }
    printf("%c ",nodes[root].data);
}

非递归深度优先遍历：后序遍历

void PostDFS(int root,Node* nodes){
    stack<int> s;
    s.push(root);
    int prev= -1;
    while(!s.empty()){
        int now = s.top();
        if(nodes[now].children.size() != 0 // 还有子节点
           && prev != nodes[now].children.back()){ // 回溯，上一个节点是最后一个遍历的子节点
            for(int i= nodes[now].children.size()-1; i>=0;--i){
                int post = nodes[now].children[i];
                s.push(post);
            }
        } else {
            s.pop();
            printf("%c ",nodes[now].data);// 出栈访问
        }
        prev = now;
    }
}

1.2 广度优先遍历(Breath First Search)

广度优先遍历：从根节点开始从上到下按照层依次遍历。

在这里插入图片描述

上图树的广度优先遍历结果：A → B → C → D → E → F → G → H → I → J

void BFS(int root,Node* nodes){
    queue<int> s;
    s.push(root);
    printf("%c ",nodes[root].data);// 入队访问
    while(!s.empty()){
        int now = s.front();
        s.pop();
        for(int i= 0;i<nodes[now].children.size();++i){
            int post = nodes[now].children[i];
            s.push(post);
            printf("%c ",nodes[post].data);// 入队访问
        }
    }
}
  • 完整测试程序
#include <bits/stdc++.h>
using namespace std;

struct Node{// 孩子表示法
   char data;
   vector<int> children;
};

// 非递归深度优先遍历：先序遍历
void PreDFS(int root,Node* nodes){
    stack<int> s;
    s.push(root);
    while(!s.empty()){
        int now = s.top();
        s.pop();
        printf("%c ",nodes[now].data);// 出栈访问
        for(int i= nodes[now].children.size()-1; i>=0;--i){// 逆序遍历
            int post = nodes[now].children[i];
            s.push(post);
        }
    }
}
// 递归深度优先遍历：先序遍历
void RecurtionPreDFS(int root,Node* nodes){
    printf("%c ",nodes[root].data);
    for(int i= 0;i<nodes[root].children.size();++i){
        int post = nodes[root].children[i];
        RecurtionPreDFS(post,nodes);
    }
}
// 非递归深度优先遍历：后序遍历
void PostDFS(int root,Node* nodes){
    stack<int> s;
    s.push(root);
    int prev= -1;
    while(!s.empty()){
        int now = s.top();
        if(nodes[now].children.size() != 0 // 还有子节点
           && prev != nodes[now].children.back()){ // 回溯，上一个节点是最后一个遍历的子节点
            for(int i= nodes[now].children.size()-1; i>=0;--i){
                int post = nodes[now].children[i];
                s.push(post);
            }
        } else {
            s.pop();
            printf("%c ",nodes[now].data);// 出栈访问
        }
        prev = now;
    }
}
// 递归深度优先遍历：后序遍历
void RecurtionPostDFS(int root,Node* nodes){
    for(int i= 0;i<nodes[root].children.size();++i){
        int post = nodes[root].children[i];
        RecurtionPostDFS(post,nodes);
    }
    printf("%c ",nodes[root].data);
}
// 非递归广度优先遍历
void BFS(int root,Node* nodes){
    queue<int> s;
    s.push(root);
    printf("%c ",nodes[root].data);// 入队访问
    while(!s.empty()){
        int now = s.front();
        s.pop();
        for(int i= 0;i<nodes[now].children.size();++i){
            int post = nodes[now].children[i];
            s.push(post);
            printf("%c ",nodes[post].data);// 入队访问
        }
    }
}

int depth(int root,Node* nodes){
    int maxDep = 0;
    for(int i = 0;i<nodes[root].children.size();++i){
        int post = nodes[root].children[i];
        int dep = depth(post,nodes);
        maxDep = max(dep,maxDep);
    }
    return maxDep+1;
}

// 递归广度优先遍历
void RecurtionBFS(int root,Node* nodes,int level){
    if(0 == level) return;
    if(1 == level) {
        printf("%c ",nodes[root].data);
        return;
    }
    for(int i = 0;i<nodes[root].children.size();++i){
        int post = nodes[root].children[i];
        RecurtionBFS(post,nodes,level-1);
    }
}
void RecurtionBFS(int root,Node* nodes){
    int dep = depth(root,nodes);
    for(int i= 1;i<=dep;++i){// 按层次打印
        RecurtionBFS(root,nodes,i);
    }
}

int main() {
   Node nodes[10] = {
       {'A',{1,2}},
       {'B',{3}},
       {'C',{4,5}},
       {'D',{6,7,8}},
       {'E',{9}},
       {'F'},
       {'G'},
       {'H'},
       {'I'},
       {'J'}
   };
   int root = 0;
   printf("非递归深度优先遍历：先序遍历\n");
   PreDFS(root,nodes);
   printf("\n递归深度优先遍历：先序遍历\n");
   RecurtionPreDFS(root,nodes);
   printf("\n非递归深度优先遍历：后序遍历\n");
   PostDFS(root,nodes);
   printf("\n递归深度优先遍历：后序遍历\n");
   RecurtionPostDFS(root,nodes);
   printf("\n非递归广度优先遍历\n");
   BFS(root,nodes);
   printf("\n递归广度优先遍历\n");
   RecurtionBFS(root,nodes);
   printf("\n树的深度:%d\n",depth(root,nodes));
   return 0;
}
  • 练习

LeetCode 589. N叉树的前序遍历
LeetCode 590. N叉树的后序遍历
LeetCode 429. N叉树的层序遍历
LeetCode 559. N叉树的最大深度
枪挑一条线、棍扫一大片

(重要)2. 二叉树遍历

二叉树通常使用链式存储。

struct Node{// 孩子表示法
   char data;
   struct Node* right;
   struct Node* left;
};

二叉树的广度优先遍历与多叉树的广度优先遍历是一样的，因为是层次遍历，所以也称为层次遍历。
二叉树的深度优先遍历，根据父节点与左右子节点访问顺序的不同，而分为三类：

  • 前序遍历(Pre-order Traversal)
  • 中序遍历(In-order Traversal)
  • 后序遍历(Post-order Traversal)
    在这里插入图片描述

深度优先遍历三种遍历方式各有两种实现方式。

2.1 深度优先遍历

2.1.1 前序遍历(Pre-order Traversal)

在这里插入图片描述

上图前序遍历结果：A → B → D → E → C → F → G
前序遍历步骤：

  • 访问根节点
  • 递归遍历左子树
  • 递归遍历右子树

直到所有节点都被访问。

2.1.2 后序遍历(Post-order Traversal)

在这里插入图片描述

上图后序遍历结果：D → E → B → F → G → C → A
后序遍历步骤：

  1. 访问根节点
  2. 递归遍历右子树
  3. 递归遍历左子树

直到所有节点都被访问。

2.1.3 中序遍历(In-order Traversal)

在这里插入图片描述

上图中序遍历结果：D → B → E → A → F → C → G
中序遍历步骤：

  1. 递归遍历左子树
  2. 访问根节点
  3. 递归遍历右子树

直到所有节点都被访问。

2.2 广度优先遍历

在这里插入图片描述

上图后序遍历结果：A → B → C → D → E → F → G
后序遍历步骤：

访问根节点
按层次从上到下依次遍历

  • 完整测试程序
#include <bits/stdc++.h>
using namespace std;

struct Node{// 孩子表示法
   char data;
   struct Node* left;
   struct Node* right;
};
// 递归深度优先遍历：先序遍历
void RecurtionPreDFS(Node* nodes){
    if(NULL != nodes){
        printf("%c ",nodes->data);
        RecurtionPreDFS(nodes->left);
        RecurtionPreDFS(nodes->right);
    }
}
// 递归深度优先遍历：后序遍历
void RecurtionPostDFS(Node* nodes){
    if(NULL != nodes){
        RecurtionPostDFS(nodes->left);
        RecurtionPostDFS(nodes->right);
        printf("%c ",nodes->data);
    }
}
// 递归深度优先遍历：中序遍历
void RecurtionInDFS(Node* nodes){
    if(NULL != nodes){
        RecurtionInDFS(nodes->left);
        printf("%c ",nodes->data);
        RecurtionInDFS(nodes->right);
    }
}
// 非递归深度优先遍历：先序遍历
void PreDFS2(Node* nodes){
    if(NULL == nodes) return;
    stack<Node*> s;// 保存已访问的节点
    s.push(nodes);
    while(!s.empty()){
        Node* now = s.top();
        s.pop();
        printf("%c ",now->data);
        if(NULL != now->right) s.push(now->right);
        if(NULL != now->left) s.push(now->left);
    }
}
void PreDFS(Node* nodes){
    stack<Node*> s;
    Node* now = nodes;
    while(NULL != now||!s.empty()){
        if(NULL != now){
            printf("%c ",now->data); // 打印节点  
            s.push(now);
            now = now->left;  // 左侧有节点
        }else{
            Node* p = s.top(); 
            s.pop();
            now = p->right;
        }
    }
}
// 非递归深度优先遍历：中序遍历
void InDFS2(Node* nodes){
    stack<Node*> s;
    Node* now = nodes;
    while(NULL != now||!s.empty()){
        if(NULL != now){ 
            s.push(now);
            now = now->left;  // 左侧有节点
        }else{
            Node* p = s.top(); 
            s.pop();
            printf("%c ",p->data); // 打印节点 
            now = p->right;
        }
    }
}
// 中序
void InDFS(Node* nodes){
    stack<Node*> s;
    Node *prev = NULL,*now = NULL; // 记录当前节点和上一个节点之间的关系
    s.push(nodes);
    while(!s.empty()){
        now = s.top();
        if(NULL == prev // now为根节点
            || prev->left == now || prev->right == now // prev是now的父节点
          ){
            if(NULL != now->left){
                s.push(now->left); // 左孩子入栈
            }else if(NULL != now->right){
                s.push(now->right); // 右孩子入栈
            }
        }else if(now->left == prev){ // prev是now的左孩子(回溯)
            printf("%c ",now->data); // 打印节点
            if(NULL != now->right){
                s.push(now->right); // 右孩子入栈
            }
        }else if(now->right == prev){ // prev是now的右孩子(回溯)
            s.pop();
        }else{
            printf("%c ",now->data); // 打印节点
            s.pop();
        }
        prev = now;
    }
}
// 非递归深度优先遍历：后序遍历
// 使用双栈，将先序遍历逆序
void PostDFS(Node* nodes){
    stack<Node*> s;
    stack<Node*> t; //1.添加结果栈
    Node* now = nodes;
    while(NULL != now||!s.empty()){
        if(NULL != now){
            t.push(now); // 2.将打印数据入栈  
            s.push(now);
            now = now->right;  // 3.左右调换
        }else{
            Node* p = s.top(); 
            s.pop();
            now = p->left; // 3.左右调换
        }
    }
    while(!t.empty()){ // 4.打印结果栈
        Node* p = t.top(); 
        t.pop();
        printf("%c ",p->data); // 打印节点
    }
}
void PostDFS2(Node* nodes){
    stack<Node*> s;
    Node *prev = NULL,*now = NULL; // 记录当前节点和上一个节点之间的关系
    s.push(nodes);
    while(!s.empty()){
        now = s.top();
        if(NULL == prev // now为根节点
            || prev->left == now || prev->right == now // prev是now的父节点
          ){
            if(NULL != now->left){
                s.push(now->left); // 左孩子入栈
            }else if(NULL != now->right){
                s.push(now->right); // 右孩子入栈
            }
        }else if(now->left == prev){ // prev是now的左孩子(回溯)
            if(NULL != now->right){
                s.push(now->right); // 右孩子入栈
            }
        }else{
            printf("%c ",now->data); // 打印节点
            s.pop();
        }
        prev = now;
    }
}
// 广度优先遍历
void BFS(Node* nodes){
    queue<Node*> s;
    s.push(nodes);
    printf("%c ",nodes->data);// 入队访问
    while(!s.empty()){
        Node* now = s.front();
        s.pop();
        if(NULL != now->left){
            s.push(now->left);
            printf("%c ",now->left->data);// 入队访问
        }
        if(NULL != now->right){
            s.push(now->right);
            printf("%c ",now->right->data);// 入队访问
        }
    }
}
int Depth(Node* nodes){
    if(NULL == nodes) return 0;
    return max(Depth(nodes->right),Depth(nodes->right))+1;
}

// 递归广度优先遍历
void RecurtionBFS(Node* nodes,int level){
    if(NULL == nodes || 0 == level) return;
    if(1 == level){
        printf("%c ",nodes->data);
    }
    RecurtionBFS(nodes->left,level-1);
    RecurtionBFS(nodes->right,level-1);
}

void RecurtionBFS(Node* nodes){
    if(NULL == nodes) return;
    int dep = Depth(nodes);
    for(int i=1;i<=dep;++i){
        RecurtionBFS(nodes,i);
    }
}

int main() {
    
    // 叶子节点
    Node d = {'D',NULL,NULL};
    Node e = {'E',NULL,NULL};
    Node f = {'F',NULL,NULL};
    Node g = {'G',NULL,NULL};

    // 分支节点
    Node b = {'B',&d,&e};
    Node c = {'C',&f,&g};
    
    // 根节点
    Node a = {'A',&b,&c};
    Node* root = &a;

   printf("\n递归深度优先遍历：先序遍历\n");
   RecurtionPreDFS(root);
   printf("\n递归深度优先遍历：后序遍历\n");
   RecurtionPostDFS(root);
   printf("\n递归深度优先遍历：中序遍历\n");
   RecurtionInDFS(root);

   printf("\n非递归深度优先遍历：先序遍历\n");
   PreDFS(root);
   printf("\n");
   PreDFS2(root);
   printf("\n非递归深度优先遍历：后序遍历\n");
   PostDFS(root);
   printf("\n");
   PostDFS2(root);
   printf("\n非递归深度优先遍历：中序遍历\n");
   InDFS(root);
   printf("\n");
   InDFS2(root);

   printf("\n广度优先遍历\n");
   BFS(root);
   printf("\n递归广度优先遍历\n");
   RecurtionBFS(root);
   printf("\n");
   printf("树的深度:%d\n",Depth(root));
}

3.练习

  • 中序遍历
    在这里插入图片描述

  • 前序遍历
    在这里插入图片描述

  • 后序遍历
    在这里插入图片描述

  • 层次遍历.png

练习

LeetCode 100. 相同的树
LeetCode 144. 二叉树的前序遍历
LeetCode 94. 二叉树的中序遍历
LeetCode 145. 二叉树的后序遍历
LeetCode 102. 二叉树的层次遍历
LeetCode 104. 二叉树的最大深度
LeetCode 111. 二叉树的最小深度

阿华田咯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树的括号表示法，二叉树的遍历，二叉树的树形打印输出（C++）
01-19
根据括号表达式构造二叉树，对二叉树进行前序，中序，后序，层序遍历，并用树形方式打印输出，有详细注释，供C++数据结构课程学习与交流使用。
二叉树在线性内存中存储表示方法
weixin_30251587的博客
03-10 223
普通树转换为二叉树进行存储过程： 设法保证任意一个节点的左指针域执行它的第一个孩子节点，右指针域指向它的下一个兄弟节点! 森林转二叉树，先将每棵树转二叉树，然后合并，合并规则同上! 两种方式 1）数组 在数组中摆放非线性的二叉树数据，数据可以放进数组中，但是我们无法再找回原来的关系图。 如下面这图中树的结构示意图所示 所以引入了一些关于...
数据结构与算法5:树的表示法
weixin_42278523的博客
07-26 343
1. 多叉树表示法 1.1 双亲表示法 表格表示 参考代码 struct Node{ char data; int parent; }; Node nodes[n]; 优缺点 比较容易找到双亲，但是不容易找到孩子。 2.2 孩子表示法 表格表示 参考代码 struct Node{ char data; vector<int> children; }; Node nodes[n]; 优缺点 比较容易找到孩子，但是不容易找到双
二叉树的表达
一只小萌新的博客
01-15 829
二叉树的表达前言一、二叉树二、相关概念简介三、例题1.输入2.输出3.输入及输出示例输入输出四、代码讲解1.结构体定义2.深度配置函数3.高度配置函数4.兄弟结点函数五、完整代码六、总结 前言   本文旨在复习数据结构之二叉树，并结合一道例题详细分析。 一、二叉树   定义：如果一棵树拥有1个根结点，且所有结点的子结点数都不超过2（不是只有0和2），那么这棵树成为有根二叉树。如下图所示就是一个二叉树的例子。 二、相关概念简介   1、根：根是唯一一个没有父结点的结点。   2、叶结点：我们将没有子结点的结
二叉树结构数组表示法
瑶の博客
12-18 3281
//二叉树结构数组表示法 #include using namespace std; #define MAX 32768 int n; struct tree { int left; int date; int right; }; struct tree b_tree[MAX]; void create(int *node,int len) { int i; int level;
数据与算法课程：6 树与二叉树.pdf
06-15
数据与算法是计算机科学的基础，其中树和二叉树是重要的数据结构，广泛应用于各种算法设计和问题解决中。在本课程中，我们将深入探讨树的相关概念和特性，特别是二叉树及其应用。 首先，我们要理解什么是树。树是一...
数据结构与算法树与二叉树
01-31
数据结构与算法树与二叉树 树是一种非线性数据结构，常用于存储和管理大量数据。它由节点和边组成，每个节点都包含一个值和一个或多个子节点的指针。树的基本信息包括定义、基本术语、森林与树的关系、树结构与线性...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
《数据结构与算法：Java语言描述》源码.zip
最新发布
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
数据结构与算法（二叉树）
12-23
数据结构与算法（二叉树） 树型结构是一种重要的非线性结构，在我们的客观世界和现实生活中大量存在。 在计算机领域也常用到树形结构。例如编译程序中用树表示源程序语法结构，数据库系统中用树组织信息等等。 我们...
DepthFirstSearch:深度搜索优先算法的C＃实现
03-30
深度优先搜索
二叉树的表示方式及遍历
weixin_41377572的博客
08-23 182
二叉树的基本知识
二叉树的性质、表示方法和简单面试题
smell201611010513的博客
04-30 3075
一、二叉树的一些概念 1.定义 树是一种非线性的数据结构，它是由n(n>=0)个有限结点组成一个由层次关系的集合。 2.树的特点 每个结点有零个或多个子结点。没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树。 3.节点的度 一个节点含有的子树个数称为该节点的度。 4.叶节点或终端节点 度为0的节点称为叶子节点。 ...
【二叉树的表示--05】
weixin_49381033的博客
03-14 631
树的同构学习 理解： 给定两棵树T1和T2，如果T1可以通过若干次的左右孩子互换变成T2，那么我们称两棵树是同构的。分别判断每个结点的子树是否相同。注意只能左右的互换，子树必须形式完全相同 注意可以按任意方式进行输入 题目描述： 解题思路： 我的思路：首先读入两个序列；然后根据所读的序列进行建树操作；其次对比两棵树是否同构；最后如果同构返回YES，非同构返回NO。 陈越数据结构解题思路： 二叉树的表示（链表/数组） 建立二叉树（从输入数据建立二叉树） 同构判别 思路基本一致。 结构数组（静态链
二叉树
maoliran的博客
07-20 443
一、二叉树的性质1、第K层的二叉树节点个数最多为2^(k - 1)个2、k层的二叉树节点个数最多有2^(k) - 1个3、度数为2的节点个数n2等于叶子节点个数n0减，即n2 + 1 = n04、第i个节点的左孩子为2i，右孩子为（2i + 1），根节点从1开始5、具有N个节点的二叉树的深度为log2(N)的下界 + 1二、树的表示方法 1、二叉链表表示法typedef struct TreeNo
总结学习二叉树2-树的三种表示方法
weixin_42562387的博客
03-13 2016
树的表示 树有很多表示方式,如: 双亲表示法   取一块连续的内存空间，在存储每个结点的同时，各自都附加一个记录其父结点位置的变量。 需要在树结构中频繁地查找某结点的父结点时，使用双亲表示法比较合适. 代码表示: #define nodeNum 50 typedef struct PNode { 　　int _data;　　//树中结点的数据类型 　　int _parent;　　　　 //结点的父结点在数组中的位置下标 }PNode; typedef struct { 　　PNode _node[
各种各样的二叉树你还记得它们都是什么吗？ 简单介绍基本的6种二叉树及操作（一）
wdshhh的博客
05-28 1203
二叉树的基本概念 结点的度：指一个结点的拥有多少个孩子结点 如1号结点有俩个孩子，所以1号结点的度为2。而7号结点无孩子，所以7号结点的度为0。 树的度 ：所有结点中最高的度数就是结点的度。 叶子结点：无孩子结点的结点。 分支结点：除了叶子结点的结点（即有孩子的结点） ** ...
数据结构学习（二叉树：一（二叉树及其表示））
weixin_43723259的博客
08-02 276
树 通过前面的学习，我们主要学习了几种线性的数据结构，根据其实现方式，我们可以大致将其分为两种：基于数组的实现与基于链表的实现。正如我们看到，就其效率而言，二者各有长短。 前者允许我们通过下标或秩，在常数时间内找到目标元素；然而对其修改时（插入或删除）则需要线性时间。 后者允许我们借助引用或位置对象，在常数时间内插入或删除对象；但是为了找出特定次序的元素，我们却不得不花费线性的时间。 而树这种结构会在同时优化静态以及动态的操作。 有根树 从图论的角度看，树等价于连通无环图。树由一组顶点以及联接与其间的若干条
数据结构：树的概念介绍及几种表示方法，以及二叉树介绍和二叉树的性质
m0_56611833的博客
11-21 620
文章目录树的概念树的表示方法（代码实现结构定义）二叉树概念满二叉树完全二叉树二叉树的一些性质 树的概念 有别于之前学的顺序表、链表、栈、队列等线性结构，树是一种非线性结构。 树是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树有一个特殊的结点，称为根结点，根节点没有前驱结点； 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一
二叉树的实验小结.pdf
11-11
在《数据结构》课程的实验报告中，主要研究了二叉树在表示代数表达式中的应用。实验的核心目标是输入一个包含数字、字母、运算符号（如 +、-、*、/ 和括号）的正确表达式，然后通过构建二叉树来实现其结构。二叉树的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值