【数据结构】二叉树顺序结构、链式结构的实现、遍历二叉树（前序 中序 后序 层序）

于 2023-05-23 23:27:12 发布
阅读量875 收藏 4
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Crocodile1006/article/details/130836744
版权

文章目录

1.二叉树结构实现

1.1顺序结构的实现

  在之前的文章中，我们对二叉树有了一定的了解，这里我们会对二叉树再进行一些内容的补充。

  普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。
  现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
在这里插入图片描述
 
在C语言定义一个简单顺序二叉树：

// 顺序存储结构二叉树
typedef struct {
    int data[MAX_TREE_SIZE + 1];   // 数组存储结构
    int size;                      // 当前二叉树的大小
} SeqBinaryTree;

//堆
typedef int HPDataType;
typedef struct Heap
{
	HPDataType* _a;
	int _size;
	int _capacity; 
}Heap;

 
  虽然二叉树结构不完整的情况下，需要预留足够的空间，可能会浪费部分存储空间，但是在实际应用中，顺序结构二叉树还是运用的较为广泛，完全二叉树的存储和操作，用于堆排序、哈夫曼编码等算法的实现。
  以下是顺序结构二叉树的优点：

  （1）实现简单：使用数组实现，不需要内存动态分配，也不需要链表结构复杂的指针操作，实现简单。

  （2）存储方便：可以将完全二叉树按顺序存储，不需要为每个结点存储指针信息，节省空间。

  （3）存储结构稳定：由于整个二叉树在一块连续的内存中，顺序存储结构的稳定性优于链式存储结构，不容易出现内存泄漏或内存碎片等问题。

  （4）访问效率高：由于顺序结构二叉树是连续存储的，可以通过下标快速访问任意结点，访问效率高。

  （5）空间利用率高：在完全二叉树的情况下，顺序结构二叉树的空间利用率非常高，每个节点的位置都是有意义的，不需要浪费额外的空间。
 

顺序结构二叉树的实现（参考）

#include <stdio.h>
#include <stdlib.h>

#define MAX_TREE_SIZE 100

// 顺序存储结构二叉树
typedef struct {
    int data[MAX_TREE_SIZE + 1];   // 数组存储结构，下标从1开始
    int size;                      // 当前二叉树的大小
} SeqBinaryTree;

// 初始化二叉树
void init(SeqBinaryTree *tree) {
    tree->size = 0;
}

// 判断二叉树是否为空
int is_empty(SeqBinaryTree *tree) {
    return tree->size == 0;
}

// 返回二叉树的元素个数
int size(SeqBinaryTree *tree) {
    return tree->size;
}

// 获取二叉树的根结点
int get_root(SeqBinaryTree *tree) {
    if (is_empty(tree)) {
        printf("Binary tree is empty.\n");
        exit(0);
    }
    return tree->data[1];
}

// 获取指定节点的父亲节点
int get_parent(SeqBinaryTree *tree, int index) {
    if (is_empty(tree)) {
        printf("Binary tree is empty.\n");
        exit(0);
    } else if (index == 1) {
        printf("This node is root, no parent node.\n");
        exit(0);
    }
    return tree->data[index / 2];
}

// 获取指定节点的左儿子节点
int get_left_child(SeqBinaryTree *tree, int index) {
    if (is_empty(tree)) {
        printf("Binary tree is empty.\n");
        exit(0);
    } else if (index * 2 > tree->size) {
        printf("This node does not have a left child.\n");
        exit(0);
    }
    return tree->data[index * 2];
}

// 获取指定节点的右儿子节点
int get_right_child(SeqBinaryTree *tree, int index) {
    if (is_empty(tree)) {
        printf("Binary tree is empty.\n");
        exit(0);
    } else if (index * 2 + 1 > tree->size) {
        printf("This node does not have a right child.\n");
        exit(0);
    }
    return tree->data[index * 2 + 1];
}

// 插入节点
void insert(SeqBinaryTree *tree, int data) {
    if (tree->size >= MAX_TREE_SIZE) {
        printf("Binary tree is full.\n");
        exit(0);
    }
    tree->size++;
    tree->data[tree->size] = data;
}

// 销毁二叉树
void destroy(SeqBinaryTree *tree) {
    tree->size = 0;
    printf("Binary tree has been destroyed.\n");
}

 

1.2链式结构的实现

用C语言简单定义一个链式二叉树

typedef int BTDataType;
typedef struct BinaryTreeNode
{
 BTDataType _data;
 struct BinaryTreeNode* _left;
 struct BinaryTreeNode* _right;
}BTNode;

 

链式结构的二叉树有以下优点：

  （1）结构灵活：链式二叉树的结构比较灵活，可以根据实际情况动态调整，不需要预先确定容量大小。

  （2）空间利用率高：链式二叉树在节点不规则的情况下，可以避免像顺序结构二叉树那样浪费大量的存储空间，空间利用率较高。

  （3）插入和删除效率高：链式结构二叉树在节点插入和删除操作时，不需要像顺序结构二叉树那样移动大量的节点，因此其插入和删除效率更高。

  （4）实际使用灵活：在实际应用中，链式二叉树可以非常容易地实现出友好的API（例如用C++实现模板化的二叉树），或在容器内部作为辅助数据结构来完成各种复杂功能。

  链式结构二叉树一般适用于非满二叉树/不规则二叉树的情况，在树的结点数量和深度变化频繁的情况下，链式二叉树更能体现出其优点。尤其是对于二叉搜索树等数据结构，链式二叉树使用起来更加方便，也更加实用一些。
 

链式结构二叉树的实现（参考）

#include<stdio.h>
#include<stdlib.h>

struct node {
    int data;  //节点的值
    struct node *left;  //指向左子节点的指针
    struct node *right;  //指向左子节点的指针
};

//插入节点的函数
struct node* insert(struct node* root, int data) {
    //如果根节点为空，新建一个节点并将它作为根节点
    if (root == NULL) {
        root = (struct node*)malloc(sizeof(struct node));
        root->data = data;
        root->left = NULL;
        root->right = NULL;
    }
    //如果节点不为空，则比较它和当前节点的值，决定向左或向右插入
    else {
        if (data < root->data) {
            root->left = insert(root->left, data);
        } else if (data > root->data) {
            root->right = insert(root->right, data);
        }
    }
    return root;
}

//中序遍历函数
void inorder(struct node *root) {
    if (root == NULL) {
        return;
    }
    inorder(root->left);
    printf("%d ", root->data);
    inorder(root->right);
}

int main() {
    struct node *root = NULL;
    root = insert(root, 9);
    insert(root, 6);
    insert(root, 15);
    insert(root, 3);
    insert(root, 8);
    insert(root, 12);
    insert(root, 18);
    printf("中序遍历结果：");
    inorder(root);
    printf("\n");
    return 0;
}

 

2.堆的概念和介绍

  堆就是顺序结构二叉树。

  如果有一个关键码的集合K = { K0，K1 ，K2 ，K3…，Kn-1 }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki<=K2i+1 且Ki<= K2i+2 (Ki >=K2i+1 且 Ki>=K2i+2 ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆有以下性质：
 （1）堆中某个节点的值总是不大于或不小于其父节点的值；
 （2）堆总是一棵完全二叉树。

 
堆的C语言简单实现（参考）

#include <stdio.h>

#define MAX_HEAP_SIZE 100

typedef struct {
    int data[MAX_HEAP_SIZE];
    int size;
} MaxHeap;

// 插入元素
void insert(MaxHeap *heap, int value) {
    int i = ++(heap->size);
    while (i != 1 && value > heap->data[i/2]) {
        heap->data[i] = heap->data[i/2];
        i = i/2;
    }
    heap->data[i] = value;
}

// 删除堆顶元素
int delete(MaxHeap *heap) {
    if (heap->size == 0) {
        printf("堆已经为空，无法继续删除！\n");
        return -1;
    }

    int max = heap->data[1];
    int last = heap->data[heap->size--];
    int i = 1, child;
    while (i*2 <= heap->size) {
        child = i*2;
        if (child+1 <= heap->size && heap->data[child+1] > heap->data[child])
            child++;
        if (last < heap->data[child])
            heap->data[i] = heap->data[child];
        else
            break;
        i = child;
    }
    heap->data[i] = last;
    return max;
}

// 查找堆顶元素
int find_max(MaxHeap heap) {
    if (heap.size == 0) {
        printf("堆已经为空！\n");
        return -1;
    }

    return heap.data[1];
}

// 堆排序
void heap_sort(MaxHeap *heap) {
    while (heap->size != 0) {
        printf("%d ", delete(heap));
    }
}

int main() {
    MaxHeap heap = {{0}, 0};
    insert(&heap, 6);
    insert(&heap, 12);
    insert(&heap, 8);
    insert(&heap, 15);
    insert(&heap, 5);
    insert(&heap, 10);

    printf("堆排序结果：");
    heap_sort(&heap);
    printf("\n");

    return 0;
}

 

3.二叉树的遍历

  所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
在这里插入图片描述
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

（1）前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
（2）中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
（3）后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

在这里插入图片描述

3.1前序遍历

  二叉树的前序遍历是指按照 根节点-左子树-右子树  的遍历顺序，遍历整棵树。可以使用递归或迭代算法实现前序遍历。
 
C语言递归实现前序遍历：

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void preorderTraversal(struct TreeNode* root){
    if(root == NULL){
        return;
    }
    printf("%d ", root->val);  // 访问根节点
    preorderTraversal(root->left);  // 递归左子树
    preorderTraversal(root->right);  // 递归右子树
}

C语言迭代算法使用栈实现：

void preorderTraversal(struct TreeNode* root){
    if(root == NULL){
        return;
    }

    struct TreeNode *stack[1000];  // 定义一个栈
    int top = 0;
    stack[top++] = root;  // 将根节点压入栈中

    while(top > 0){
        struct TreeNode *p = stack[--top];  // 弹出栈顶元素
        printf("%d ", p->val);  // 访问根节点

        if(p->right){  // 先将右子树节点压入栈中
            stack[top++] = p->right;
        }
        if(p->left){  // 将左子树节点压入栈中
            stack[top++] = p->left;
        }
    }
}

 

3.2中序遍历

  二叉树的前序遍历是指按照 左节点-根子树-右子树  的遍历顺序，遍历整棵树。可以使用递归或迭代算法实现前序遍历。
 
C语言递归实现中序遍历：

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void inorderTraversal(struct TreeNode* root){
    if(root == NULL){
        return;
    }
    inorderTraversal(root->left);  // 递归左子树
    printf("%d ", root->val);  // 访问根节点
    inorderTraversal(root->right);  // 递归右子树
}

C语言迭代算法使用栈实现：

void inorderTraversal(struct TreeNode* root){
    if(root == NULL){
        return;
    }

    struct TreeNode *stack[1000];  // 定义一个栈
    int top = 0;
    struct TreeNode *p = root;

    while(p != NULL || top > 0){
        while(p != NULL){  // 将左子树节点压入栈中
            stack[top++] = p;
            p = p->left;
        }

        if(top > 0){  // 弹出栈顶元素
            p = stack[--top];
            printf("%d ", p->val);  // 访问根节点
            p = p->right;  // 将右子树节点压入栈中
        }
    }
}

 

3.3后序遍历

  二叉树的前序遍历是指按照 左节点-右子树-根子树  的遍历顺序，遍历整棵树。可以使用递归或迭代算法实现前序遍历。
 
C语言递归实现后序遍历：

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void postorderTraversal(struct TreeNode* root){
    if(root == NULL){
        return;
    }
    postorderTraversal(root->left);  // 递归左子树
    postorderTraversal(root->right);  // 递归右子树
    printf("%d ", root->val);  // 访问根节点
}

C语言迭代算法使用栈实现：

void postorderTraversal(struct TreeNode* root){
    if(root == NULL){
        return;
    }

    struct TreeNode *stack1[1000];  // 定义两个栈
    struct TreeNode *stack2[1000];
    int top1 = 0, top2 = -1;
    struct TreeNode *p = root;

    while(p != NULL || top1 > 0){  // 遍历所有节点
        while(p != NULL){  // 先将左子树入栈1
            stack1[top1++] = p;
            stack2[++top2] = 0;  // 将当前节点在栈2中标记为未访问
            p = p->left;
        }

        while(top1 > 0 && stack2[top2] == 1){  // 当栈1非空且栈顶节点在栈2中已经被标记时，弹出节点并访问
            p = stack1[--top1];
            printf("%d ", p->val);
            top2--;
        }

        if(top1 > 0){  // 将栈顶节点右子节点入栈1，并在栈2中标记为未访问
            p = stack1[top1-1]->right;
            stack2[top2] = 1;
        }
        else{  // 如果栈1为空，则遍历结束
            break;
        }
    }
}

 

3.4层序遍历

  二叉树的层序遍历是指按照树的层次  顺序逐层遍历 即从上到下，从左到右遍历每一层的所有节点。可以通过队列来实现二叉树的层序遍历。

C语言队列实现层序遍历：

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

void levelOrderTraversal(struct TreeNode* root){
    if(root == NULL){
        return;
    }

    struct TreeNode *queue[1000];  // 定义一个队列
    int front = 0, rear = 0;
    queue[rear++] = root;  // 将根节点入队

    while(front < rear){  // 队列非空时循环
        struct TreeNode *p = queue[front++];  // 取出队首节点并访问
        printf("%d ", p->val);

        if(p->left){  // 将左子节点入队
            queue[rear++] = p->left;
        }
        if(p->right){  // 将右子节点入队
            queue[rear++] = p->right;
        }
    }
}

这些就是数据结构中有关二叉树实现和遍历的简单介绍了😉
如有错误❌望指正，最后祝大家学习进步✊天天开心✨🎉

鳄鱼麻薯球
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实验五 二叉树的操作
沉默的大多数
11-26 7247
ZZU的学弟学妹们不要抄作业哦~(｀Д´) 一、实验目的 1．理解二叉树的类型定义与性质。 2．掌握二叉树的二叉链表存储结构的表示和实现方法。 3．掌握二叉树遍历操作的算法实现。 4．熟悉二叉树遍历操作的应用。 二、实验内容 1．建立二叉树的二叉链表存储结构。 2．实现二叉树的先序、中序和后序三种遍历操作。 3．应用二叉树的遍历来实现判断两棵二叉树是否相等的操作。（选做） ...
二叉树的存储结构和二叉树的遍历方法以及实现代码
qq_51141456的博客
05-25 1580
实现代码在上述代码段中，函数为 PostOrder1(BiTree TT)、InOrder1(BiTree TT)、PreOrder1(BiTree TT)；如果二叉树如下图中所示，补全节点使其成为完全二叉树的方法太浪费空间；给定一个序列，在给定一个遍历的方法，能否将还原出二叉树呢？下图中的左右 要理解为树木，不要片面的理解成节点；答案是：不能，如下图，给定先序遍历 123。先看动图看遍历步骤，再看实例；先序遍历序列+中序遍历序列。后序遍历序列+中序遍历序列。层次遍历序列+中序遍历序列。
二叉树的二叉链表存储结构，二叉树的前序、中序、后序、层序遍历操作，求二叉树叶子结点个数并输出叶子结点的实现（c++ 数据结构 实验五）
weixin_44790790的博客
11-29 4563
一、实验内容要求 1.基于前序序列，构建二叉树的二叉链表存储结构 2.对建立的二叉树进行前序、中序、后序、层序遍历操作 3.求二叉树叶子结点个数并输出叶子结点信息 二、代码 #include <iostream> using namespace std; extern int count; //全局变量 int count = 0; struct BiNode //定义二叉链表的结点 { char data; BiNode * lchild, *
基于Python的数据结构实验——二叉树的构建与遍历（先序、中序、后序、层次遍历，修改、添加节点）（附详细代码和注释）
为人民服务
01-13 2445
（注：我使用的二叉树写入的方法是，一层一层写，有两个规矩，一是确保每一个节点的孩子都必须是写入了数据的节点或#节点，二是确保最后一个#之前不能存在空节点，即对于上述二叉树，其应该表示为ABCDEFGH##IJ#############，分层后是A|BC|DEFG|H##IJ###|##########）创建名为 prac07.py 的文件，在文件中定义两个类，一个是二叉树的结点类，该类 包含结点的相关信息(如结点的值和左、右子树);另一个是二叉树的类，该类包含二叉树的定 义及其基本操作。
算法与数据结构(十) 二叉排序树的查找、插入与删除(Swift版)
weixin_34354945的博客
11-18 318
在上一篇博客中，我们主要介绍了四种查找的方法，包括顺序查找、折半查找、插入查找以及Fibonacci查找。上面这几种查找方式都是基于线性表的查找方式，今天博客中我们来介绍一下基于二叉树结构的查找，也就是我们今天要聊的二叉排序树。今天主要聊的是二叉排序树的查找、插入与删除的内容，二叉排序的创建过程其实就是不断查找与插入的过程，也就是说当我们在创建二叉排序树时，我们会先搜索该节点在二叉排序树中的位置，...
c++数据结构-实验.zip
07-17
3）选作：编程实现二叉树的构造、前序、中序、后序、层序遍历等基本功能。 图的基本操作 1.实验内容与要求 1）理解邻接矩阵和邻接表的概念 2）任选一种存储方式实现以下操作：图的构造、深度优先遍历以及广度优先...
数据结构——二叉树有关操作程序
12-17
(3)对（1）中生成的二叉树进行遍历（分别实现先序遍历、中序遍历、后序遍历）； (4) 打印输出（3）的遍历结果； 二)二叉树的一些基本操作 (1)返回二叉树的根； (2)返回树中某个结点的左孩子，若无则返回“空”...
数据结构一学期作业(顺序栈,三元组,串,树,邻接表,邻接矩阵,二叉树,等等代码c语言实现)
02-24
一学期数据结构的代码作业,基本上涵盖了课本上面所有算法的C语言代码实现,压缩包无密码 2019/11/03 21:43 1,478 BF_KMP.cpp 2019/11/03 21:22 2,664 KMP.cpp 2019/10/24 18:49 3,956 LinkStack.cpp 2019/11/21 ...
杭州电子科技大学学生考试卷 考试课程 数据结构 试卷和答案
01-14
考试课程 数据结构 考试日期 2018 年 月 日 成 绩 课程号 A2701410 教师号 任课教师姓名 考生姓名 学号（8 位） 年级 专业 特别提醒：答案一律写在答题纸上，否则不给分。 一．判断题（每题 2 分，共 10 分）...
数据结构实验三树与二叉树的操作实验指导.pdf
09-30
数据结构实验三树与二叉树的操作实验指导 在这篇实验指导中，我们将探索树和二叉树的基本概念和操作。实验的主要目的是掌握二叉树链表的结构和二叉树的建立过程，并掌握二叉树的基本操作，逐步培养解决实际问题的...
二叉树的实现各种遍历算法
09-29
二叉树的实现各种遍历算法，插入删除成员函数非常全。二叉树的实现各种遍历算法，插入删除成员函数非常全
利用二叉树实现学生成绩排序
10-14
构建一个二叉排序树，使输入的学生信息可以按照成绩从高到低排序，放入顺序表之中，再顺序输出
算法之二叉树各种遍历
热门推荐
落日小屋
03-07 20万+
树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用。 二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度
数据结构与算法（6-3）二叉树的遍历（前序遍历、中序遍历、后序遍历、层序遍历）（层序遍历分别用队列和链队列实现）
great_yzl的博客
08-02 3455
目录 一、前序遍历 二、中序遍历 三、后序遍历 前中后序遍历总代码 四、层序遍历（队列实现(主流)） 总代码 五、层序遍历（链队列实现(自创)） 总代码 二叉树的遍历分为前序、中序、后序以及层序遍历。 前中后序是按照根结点的访问顺序来确定的，前中后序遍历的核心都是递归。 一、前序遍历 访问顺序：根->左->右 普通二叉树遍历（前序）：ABDCG 扩展二叉树遍历（前序）：ABD###C#G## 实现顺序： 1、生成根结点 2、递归遍历左子树...
二叉树、二叉树排序树的实现及遍历
ZER00000001的博客
07-23 937
对于大量的数据而言，链表的线性访问时间太慢，不宜使用。本章节将会介绍一种简单的数据结构：树（tree），其大部分操作的运行时间平均为O（logN）。在数据结构中树是非常有用的抽象概念，在本篇中我们将讨论二叉树的存储结构、二叉树的遍历和二叉排序树的实现，为后续平衡树以及高阶搜索树打下基础。我们下次将详细讲解二叉平衡树的增删查改。...
数据结构——树（链式存储上各种操作的实现）
qq_43627100的博客
12-26 245
树的相关实现代码 树的遍历 树的链式存储 树的创建——扩展前序和前序和中序生成 树的高度、叶子节点的个数 #include<bits/stdc++.h> using namespace std; struct Node { char data; Node *lchild,*rchild; }; //数据结构:树 //实现 1、扩展树初始化一棵树 //2、前中后遍历 /...
二叉树的实现以及遍历
qq_38311489的博客
04-20 468
二叉树简历 1、二叉树的定义 二叉树是每个结点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空。 2、二叉树的性质 性质1：二叉树第i层上的结点数目最多为2i-1(i>=1) 性质2：深度为k的二叉树至多有2k-1个结点（k>=1） 性质3：包含n个结点的二叉树的高度至少为(log2n)+1 性质4：在任意一棵二叉树中，若终...
二叉树的遍历（先序、中序、后序和层次遍历）
DX奥特曼的博客
12-29 3万+
采用二叉链表结构实现二叉树，并以递归遍历思想实现二叉树的创建、二叉树的遍历（先序、中序、后序和层次遍历）、二叉树叶子节点统计、二叉树深度统计的算法；同时，结合课件和实例代码，实现二叉树的中序非递归遍历算法。存储结构和操作接口定义如下: /*①二叉树的二叉链表存储结构定义*/ typedef struct BiTNode { ElemType data; struct BiTNode *l
【数据结构】二叉树的存储结构及先/中/后序递归遍历算法（C语言）
weixin_51450101的博客
02-03 4368
目录1. 树与二叉树1.1 树的基本概念1.2 二叉树的基本概念2. 二叉树的存储结构及遍历算法2.1 二叉树的存储结构2.2 二叉树的前中后序遍历2.3 遍历算法的应用2.4 完整实现代码2.5 运行结果3. 遍历算法基于栈的递归消除 1. 树与二叉树 1.1 树的基本概念 树是 n（n>=0）个结点的有限集合 T。当 n = 0 时，称为空树；当 n>0 时，该集合满足： ① 其中必有一个称为根（root）的特定结点，它没有直接前驱，但有零个或多个直接后驱。 ② 其余 n-1 个结点可以划分
二叉树的前序中序后序层序
最新发布
04-15
前序、中序、后序和层序是四种常用的遍历方式，用于按照不同的顺序访问二叉树的节点。 1. 前序遍历（Preorder Traversal）：先访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。遍历顺序为：根-左-右。 2...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

鳄鱼麻薯球

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

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

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

打赏作者

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

抵扣说明：

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

余额充值