《数据结构》-二叉树(静态数组实现)

最新推荐文章于 2022-04-18 15:25:15 发布
最新推荐文章于 2022-04-18 15:25:15 发布
阅读量944 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 二叉树 顺序数组 二叉树遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyustli/article/details/118539106
版权

静态数组实现二叉树

二叉链表实现二叉树

三叉链表实现二叉树

线索二叉树

树的基本概念

树的 结点 包含一个数据元素及若干个指向其子树的分支
结点拥有的子树数称为 结点的度
度为 0 的结点称为叶子结点或终端结点
度不为 0 的结点称为非终端节点或分支结点。除根节点外，分支结点也称为内部结点
树的度是树内各结点的度的最大值
结点的子树的根称为该结点的孩子，相应的该结点称为孩子的双亲，用一个双亲的孩子之间互称为兄弟
结点的层次从根节点开始定义，根为第一层，根的孩子为第二层
树中结点的最大层次称为树的深度

二叉树的性质

二叉树 是另一种树型结构，它的特点是每个结点至多只有两棵子树(即二叉树中不存在度大于2的结点)，且，二叉树的子树有左右之分，其次序 不能随意颠倒。

  • 在二叉树的第 i 层上至多有 2^i - 1 个结点(i>=1)

  • 深度为 k 的二叉树至多有 2^k - 1 个结点(k>=1)

  • 对任意一个二叉树 T，如果终端结点的个数为 n0，度为 2 的结点数为 n2，则 n0 = n2 + 1

  • 具有 n 个结点的完全二叉树的深度为
    在这里插入图片描述

  • 如果对一棵有 n 个结点的完全二叉树(其深度为)的结点按层序编号(从第一层到第层，每层从左到右)，则对任一结点 i(1=<i<= n)，有

    1、如果 i=1 则结点 i 是二叉树的根，无双亲；如果 i>1则其双亲是结点

    2、如果 2i>n，则结点 i 无左孩子(结点 i 为叶子结点)；否则其左孩子是结点 2i。

    3、如果 2i+1>n，则结点 i 无右孩子；否则其右孩子是结点 2i+1

二叉树的存储结构分类

在这里插入图片描述

顺序存储结构特点

按满二叉树的结点层次编号，依次存放二叉树中的数据元素

特点：节点间关系蕴含在其存储位置中，比较浪费空间，适于存满/完全二叉树

存储示例

在这里插入图片描述

在这里插入图片描述

顺序存储结构程序实现

main.c
/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-07-01     tyustli      first version
 */

#include "tree.h"

void visit(TElemType e)
{
    printf("%d ", e);
}

int main(int argc, char *argv)
{
    printf("this is tree sample \r\n");
    Status i;

    int j;
    struct position p;
    TElemType e;
    SqBiTree T, s;
    InitBiTree(T);
    CreateBiTree(T);

    printf("建立二叉树后,树空否？ %d (1:是 0:否) 树的深度 = %d \r\n", BiTreeEmpty(T), BiTreeDepth(T));

    i = Root(T, &e);
    if (i)
        printf("二叉树的根为：%d\r\n", e);
    else
        printf("树空，无根\r\n");

    printf("层序遍历二叉树:\r\n");
    LevelOrderTraverse(T, visit);

    printf("先序遍历二叉树:\r\n");
    PreOrderTraverse(T, visit);

    printf("中序遍历二叉树:\r\n");
    InOrderTraverse(T, visit);

    printf("后序遍历二叉树:\r\n");
    PostOrderTraverse(T, visit);

    printf("请输入待修改结点的层号 本层序号: ");
    scanf("%d %d", &p.level, &p.order);

    e = Value(T, p);
    printf("待修改结点的原值为 %d 请输入新值: ", e);
    scanf("%d", &e);
    Assign(T, p, e);
    printf("先序遍历二叉树:\r\n");
    PreOrderTraverse(T, visit);

    printf("结点 e 的双亲为 %d 左右孩子分别为", Parent(T, e));
    printf("%d %d ,左右兄弟分别为", LeftChild(T, e), RightChild(T, e));
    printf("%d %d \r\n", LeftSibling(T, e), RightSibling(T, e));

    return 1;
}

/*
编译：make
运行：./obj
结果：
          1
      2       3
    4   5    6   7
  8   9

this is tree sample
请按层序输入结点的值(整型)，0表示空结点，输999结束。结点数≤ 100
1
2
3
4
5
6
7
8
9
999
建立二叉树后,树空否？ 0 (1:是 0:否) 树的深度 = 4
二叉树的根为：1
层序遍历二叉树:
1 2 3 4 5 6 7 8 9
先序遍历二叉树:
1 2 4 8 9 5 3 6 7
中序遍历二叉树:
8 4 9 2 5 1 6 3 7
后序遍历二叉树:
8 9 4 5 2 6 7 3 1
请输入待修改结点的层号 本层序号: 3 2
待修改结点的原值为 5 请输入新值: 10
先序遍历二叉树:
1 2 4 8 9 10 3 6 7
结点 e 的双亲为 2 左右孩子分别为0 0 ,左右兄弟分别为4 0
*/
tree.c
/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-07-01     tyustli      first version
 */

#include "tree.h"

TElemType Nil = 0; // 设整型以0为空

// 二叉树的顺序存储的基本操作(23个)
#define ClearBiTree InitBiTree   // 在顺序存储结构中，两函数完全一样
#define DestroyBiTree InitBiTree // 在顺序存储结构中，两函数完全一样

// 构造空二叉树T。因为T是数组名，故不需要&
void InitBiTree(SqBiTree T)
{
    int i;
    for (i = 0; i < MAX_TREE_SIZE; i++)
        T[i] = Nil; // 初值为空(Nil在主程中定义)
}

// 按层序次序输入二叉树中结点的值(字符型或整型), 构造顺序存储的二叉树T
void CreateBiTree(SqBiTree T)
{
    int i = 0;
    InitBiTree(T); // 构造空二叉树T

    printf("请按层序输入结点的值(整型)，0表示空结点，输999结束。结点数≤ %d \r\n", MAX_TREE_SIZE);
    while (1)
    {
        scanf("%d", &T[i]);
        if (T[i] == 999)
        {
            T[i] = Nil;
            break;
        }
        i++;
    }

    for (i = 1; i < MAX_TREE_SIZE; i++)
    {
        if (i != 0 && T[(i + 1) / 2 - 1] == Nil && T[i] != Nil) // 此结点(不空)无双亲且不是根
        {
            printf("出现无双亲的非根结点 %d \r\n", T[i]);
            exit(-1);
        }
    }
}

// 初始条件：二叉树T存在。
// 操作结果：若T为空二叉树，则返回TRUE，否则FALSE
Status BiTreeEmpty(SqBiTree T)
{
    if (T[0] == Nil) // 根结点为空，则树空
        return TRUE;
    else
        return FALSE;
}

// 初始条件：二叉树T存在。
// 操作结果：返回T的深度
int BiTreeDepth(SqBiTree T)
{
    int i, j = -1;
    for (i = MAX_TREE_SIZE - 1; i >= 0; i--) // 找到最后一个结点
        if (T[i] != Nil)
            break;
    i++; // 为了便于计算
    do
        j++;
    while (i >= pow(2.0, j));

    return j;
}

// 初始条件：二叉树T存在。
// 操作结果：当T不空，用e返回T的根，返回OK；否则返回ERROR，e无定义
Status Root(SqBiTree T, TElemType *e)
{
    if (BiTreeEmpty(T)) // T空
    {
        return ERROR;
    }
    else
    {
        *e = T[0];
        return OK;
    }
}

// 初始条件：二叉树T存在，e是 T 中某个结点(的位置)
// 操作结果：返回处于位置 e (层,本层序号)的结点的值
TElemType Value(SqBiTree T, struct position e)
{
    return T[(int)(pow(2, e.level - 1) + e.order - 2)];
}

// 初始条件：二叉树T存在，e 是 T 中某个结点(的位置)
// 操作结果：给处于位置 e (层,本层序号)的结点赋新值 value
Status Assign(SqBiTree T, struct position e, TElemType value)
{
    int i = (int)(pow(2, e.level - 1) + e.order - 2); // 将层、本层序号转为矩阵的序号
    if (value != Nil && T[(i + 1) / 2 - 1] == Nil)    // 给叶子赋非空值但双亲为空
        return ERROR;
    else if (value == Nil && (T[i * 2 + 1] != Nil || T[i * 2 + 2] != Nil)) //  给双亲赋空值但有叶子(不空)
        return ERROR;
    T[i] = value;
    return OK;
}

// 初始条件：二叉树 T 存在，e 是 T 中某个结点
// 操作结果：若 e 是 T 的非根结点，则返回它的双亲，否则返回＂空＂
TElemType Parent(SqBiTree T, TElemType e)
{
    int i;
    if (T[0] == Nil) // 空树
        return Nil;
    for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
        if (T[i] == e) // 找到e
            return T[(i + 1) / 2 - 1];
    return Nil; // 没找到e
}

// 初始条件：二叉树T存在，e 是 T 中某个结点。
// 操作结果：返回 e 的左孩子。若 e 无左孩子,则返回"空"
TElemType LeftChild(SqBiTree T, TElemType e)
{
    int i;

    if (T[0] == Nil) // 空树
        return Nil;
    for (i = 0; i <= MAX_TREE_SIZE - 1; i++)
        if (T[i] == e) // 找到e
            return T[i * 2 + 1];
    return Nil; // 没找到e
}

// 初始条件：二叉树T存在，e 是 T 中某个结点。
// 操作结果：返回 e 的右孩子。若 e 无右孩子,则返回"空"
TElemType RightChild(SqBiTree T, TElemType e)
{
    int i;

    if (T[0] == Nil) // 空树
        return Nil;
    for (i = 0; i <= MAX_TREE_SIZE - 1; i++)
        if (T[i] == e) // 找到e
            return T[i * 2 + 2];
    return Nil; // 没找到e
}

// 初始条件：二叉树 T 存在，e 是 T 中某个结点
// 操作结果：返回 e 的左兄弟。若 e 是 T 的左孩子或无左兄弟，则返回＂空＂
TElemType LeftSibling(SqBiTree T, TElemType e)
{
    int i;
    if (T[0] == Nil) // 空树
        return Nil;
    for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
        if (T[i] == e && i % 2 == 0) // 找到e且其序号为偶数(是右孩子)
            return T[i - 1];
    return Nil; // 没找到e
}

// 初始条件：二叉树T存在，e是T中某个结点
// 操作结果：返回e的右兄弟。若e是T的右孩子或无右兄弟，则返回＂空＂
TElemType RightSibling(SqBiTree T, TElemType e)
{
    int i;
    if (T[0] == Nil) // 空树
        return Nil;
    for (i = 1; i <= MAX_TREE_SIZE - 1; i++)
        if (T[i] == e && i % 2) // 找到e且其序号为奇数(是左孩子)
            return T[i + 1];
    return Nil; // 没找到e
}

void Move(SqBiTree q, int j, SqBiTree T, int i) // InsertChild() 用到
{                                               // 把从 q 的 j 结点开始的子树移为从 T 的 i 结点开始的子树
    if (q[2 * j + 1] != Nil)                    // q 的左子树不空
        Move(q, (2 * j + 1), T, (2 * i + 1));   // 把 q 的 j 结点的左子树移为 T 的 i 结点的左子树
    if (q[2 * j + 2] != Nil)                    // q 的右子树不空
        Move(q, (2 * j + 2), T, (2 * i + 2));   // 把 q 的 j 结点的右子树移为 T 的 i 结点的右子树
    T[i] = q[j];                                // 把 q 的 j 结点移为 T 的 i 结点
    q[j] = Nil;                                 // 把 q 的 j 结点置空
}

// 初始条件：二叉树 T 存在，p 是 T 中某个结点的值，LR 为 0 或 1，非空二叉树 c 与 T 不相交且右子树为空
// 操作结果: 根据 LR 为 0 或 1,插入 c 为 T 中 p 结点的左或右子树。p 结点的原有左或右子树则成为 c 的右子树
void InsertChild(SqBiTree T, TElemType p, int LR, SqBiTree c)
{
    int j, k, i = 0;
    for (j = 0; j < (int)(pow(2, BiTreeDepth(T))) - 1; j++) // 查找p的序号
        if (T[j] == p)                                      // j为p的序号
            break;
    k = 2 * j + 1 + LR;           // k为p的左或右孩子的序号
    if (T[k] != Nil)              // p原来的左或右孩子不空
        Move(T, k, T, 2 * k + 2); // 把从T的k结点开始的子树移为从k结点的右子树开始的子树
    Move(c, i, T, k);             // 把从c的i结点开始的子树移为从T的k结点开始的子树
}

#include "queue.h"

// 初始条件：二叉树T存在，p指向T中某个结点，LR为1或0
// 操作结果：根据LR为1或0，删除T中p所指结点的左或右子树
Status DeleteChild(SqBiTree T, struct position p, int LR)
{
    int i;
    Status k = OK; // 队列不空的标志
    LinkQueue q;
    InitQueue(&q);                              // 初始化队列，用于存放待删除的结点
    i = (int)pow(2, p.level - 1) + p.order - 2; // 将层、本层序号转为矩阵的序号
    if (T[i] == Nil)                            // 此结点空
        return ERROR;
    i = i * 2 + 1 + LR; // 待删除子树的根结点在矩阵中的序号
    while (k)
    {
        if (T[2 * i + 1] != Nil)    // 左结点不空
            EnQueue(&q, 2 * i + 1); // 入队左结点的序号
        if (T[2 * i + 2] != Nil)    // 右结点不空
            EnQueue(&q, 2 * i + 2); // 入队右结点的序号
        T[i] = Nil;                 // 删除此结点
        k = DeQueue(&q, &i);        // 队列不空
    }
    return OK;
}

void (*VisitFunc)(TElemType); // 函数变量
void PreTraverse(SqBiTree T, int e)
{ // PreOrderTraverse()调用
    VisitFunc(T[e]);
    if (T[2 * e + 1] != Nil) // 左子树不空
        PreTraverse(T, 2 * e + 1);
    if (T[2 * e + 2] != Nil) // 右子树不空
        PreTraverse(T, 2 * e + 2);
}

// 初始条件：二叉树存在，Visit是对结点操作的应用函数
// 操作结果：先序遍历T，对每个结点调用函数Visit一次且仅一次

void PreOrderTraverse(SqBiTree T, void (*Visit)(TElemType))
{
    VisitFunc = Visit;
    if (!BiTreeEmpty(T)) // 树不空
        PreTraverse(T, 0);
    printf("\r\n");
}

void InTraverse(SqBiTree T, int e)
{                            // InOrderTraverse()调用
    if (T[2 * e + 1] != Nil) // 左子树不空
        InTraverse(T, 2 * e + 1);
    VisitFunc(T[e]);
    if (T[2 * e + 2] != Nil) // 右子树不空
        InTraverse(T, 2 * e + 2);
}

// 初始条件：二叉树存在，Visit是对结点操作的应用函数
// 操作结果：中序遍历T，对每个结点调用函数Visit一次且仅一次
void InOrderTraverse(SqBiTree T, void (*Visit)(TElemType))
{
    VisitFunc = Visit;
    if (!BiTreeEmpty(T)) // 树不空
        InTraverse(T, 0);
    printf("\r\n");
}

void PostTraverse(SqBiTree T, int e)
{                            // PostOrderTraverse()调用
    if (T[2 * e + 1] != Nil) // 左子树不空
        PostTraverse(T, 2 * e + 1);
    if (T[2 * e + 2] != Nil) // 右子树不空
        PostTraverse(T, 2 * e + 2);
    VisitFunc(T[e]);
}

// 初始条件：二叉树T存在，Visit是对结点操作的应用函数
// 操作结果：后序遍历T，对每个结点调用函数Visit一次且仅一次
void PostOrderTraverse(SqBiTree T, void (*Visit)(TElemType))
{
    VisitFunc = Visit;
    if (!BiTreeEmpty(T)) // 树不空
        PostTraverse(T, 0);
    printf("\r\n");
}

// 层序遍历二叉树
void LevelOrderTraverse(SqBiTree T, void (*Visit)(TElemType))
{
    int i = MAX_TREE_SIZE - 1, j;
    while (T[i] == Nil)
        i--;                 // 找到最后一个非空结点的序号
    for (j = 0; j <= i; j++) // 从根结点起，按层序遍历二叉树
        if (T[j] != Nil)
            Visit(T[j]); // 只遍历非空的结点
    printf("\r\n");
}

// 逐层、按本层序号输出二叉树
void Print(SqBiTree T)
{
    int j, k;
    struct position p;
    TElemType e;
    for (j = 1; j <= BiTreeDepth(T); j++)
    {
        printf("第 %d 层: ", j);
        for (k = 1; k <= pow(2, j - 1); k++)
        {
            p.level = j;
            p.order = k;
            e = Value(T, p);
            if (e != Nil)
                printf("k = %d e = %d", k, e);
        }
        printf("\r\n");
    }
}
tree.h
/*
 * Change Logs:
 * Date           Author       Notes
 * 2021-07-01     tyustli      first version
 */

#include <string.h>
#include <ctype.h>
#include <malloc.h> // malloc()等
#include <limits.h> // INT_MAX等
#include <stdio.h>  // EOF(=^Z或F6),NULL
#include <stdlib.h> // atoi()
#include <math.h>   // floor(),ceil(),abs()

// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status;  // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

typedef int TElemType;

// 二叉树的顺序存储表示
#define MAX_TREE_SIZE 100                  // 二叉树的最大结点数
typedef TElemType SqBiTree[MAX_TREE_SIZE]; // 0号单元存储根结点

struct position
{
    int level, order; // 结点的层,本层序号(按满二叉树计算)
};

void InitBiTree(SqBiTree T);
void CreateBiTree(SqBiTree T);
Status BiTreeEmpty(SqBiTree T);
int BiTreeDepth(SqBiTree T);
Status Root(SqBiTree T, TElemType *e);
TElemType Value(SqBiTree T, struct position e);
Status Assign(SqBiTree T, struct position e, TElemType value);
TElemType Parent(SqBiTree T, TElemType e);
TElemType LeftChild(SqBiTree T, TElemType e);
TElemType RightChild(SqBiTree T, TElemType e);
TElemType LeftSibling(SqBiTree T, TElemType e);
TElemType RightSibling(SqBiTree T, TElemType e);
void Move(SqBiTree q, int j, SqBiTree T, int i);
void InsertChild(SqBiTree T, TElemType p, int LR, SqBiTree c);
Status DeleteChild(SqBiTree T, struct position p, int LR);
void PreTraverse(SqBiTree T, int e);
void PreOrderTraverse(SqBiTree T, void (*Visit)(TElemType));
void InTraverse(SqBiTree T, int e);
void InOrderTraverse(SqBiTree T, void (*Visit)(TElemType));
void PostTraverse(SqBiTree T, int e);
void PostOrderTraverse(SqBiTree T, void (*Visit)(TElemType));
void LevelOrderTraverse(SqBiTree T, void (*Visit)(TElemType));
void Print(SqBiTree T);
makefile
objects  = main.o tree.o queue.o

obj: $(objects)
	cc -o obj $(objects) -lm

main.o : tree.h
tree.o : tree.h
queue.o : queue.h

.PHONY : clean
clean :
	-rm obj $(objects)
tyustli
关注
专栏目录
数据结构-第五期——二叉树（Python）
荷叶田田的博客
12-21 4242
二叉树满足条件：1、本身是有序树 2、树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2；
ADT（抽象数据类型）--二叉树
Turtle's trail
03-05 1693
二叉树是树的一种特殊形式，它的每个子节点至多具有2个孩子，分别是左孩子和右孩子，另外，每个节点的值比它的左子树的所有节点都大，但比它的右子树的所有节点都小，所以有了这个规则，树中就不会有重复的元素，这个特性也使二叉搜索树成为一种用关键值快速查找数据的优秀工具。 ...
二叉树 动态链表转化为静态结构数组
06-03
在编这个程序之前 其实在网上搜了很多这方面对于这个方法实现的程序 可没找到 于是自己编了一个 结构思路很容易看清楚 希望对大家有帮助
二叉树的静态实现
amf12345的博客
08-14 345
二叉树的静态实现可以满足完全不使用指针，而简单使用数组来完成二叉树的所有操作。 在定义二叉树时，采用的是二叉链表的结构，如下所示： struct node{ typename data;//数据域 node *lchild;//指向左子树的根结点的指针 node *rchild;//指向右子树的根结点的指针 }; 在这个定义中，为了能够实时控制新生成的结点的个数，结构体node中的...
静态数组实现的二叉搜索树
网络空间安全与企业信息化
01-01 1516
/*_############################################################################  _##   _##  静态数组实现的二叉搜索树  _##  Author: xwlee                           _##  Time: 2007.01.01    _##  Changan University
静态二叉树
姬小野的博客
07-14 1081
二叉树也可以是静态的, 和指针的动态所不同的是,二叉树的静态是用结构体数组实现的, 访问指针变成了访问数组下标所在结点, 原来指针指向的位置变成了存储下标. 可以说这种方法对于不了解指针的人来说是非常友好了. 结构体定义: struct Node { int data, left, right; } node[maxn]; 昨天我使用前序和后序构建静态二叉树时, 发现按照动态的方式...
C和指针学习总结之静态数组实现二叉搜索树
A_king
01-23 320
什么是二叉搜索树 树是一种数据结构，它要么为空，要么具有一个值并具有零个或多个节点，每个结点本身也是树。 二叉树是树的一种特殊形式，它的每个节点至多具有两个节点，分别称为左结点和右结点。二叉搜索树具有一个额外的属性：每个节点的值比它的左子树的所有节点的值都要大，但比它的右子树的所有节点的值都要小。这个定义排除了树中存在值相同的节点的可能性。这使树成为一种用关键值快速查找数据的优秀工具。
数据结构：静态一维数组实现栈
"采用静态一维数组来存储栈的原理及数据结构相关知识" 在数据结构中，栈是一种非常重要的抽象数据类型，它遵循后进先出（LIFO）的原则。在实际应用中，栈通常使用一维数组来实现，这是一种静态的顺序存储方式。在...
数据结构 静态二叉树
wwxy1995的博客
11-25 364
7-4 List Leaves （25 point(s)） Given a tree, you are supposed to list all the leaves in the order of top down, and left to right. Input Specification: Each input file contains one test case. For eac...
elasticsearch集群节点滚动重启操作流程
wer的博客
09-19 1763
操作前，停掉所有写入操作（重要）；然后到head插件索引 动作操作中，点击flush刷新菜单（flush是落盘操作，将暂时写入es内存的数据刷入磁盘，防止内存中少量的数据丢失） 1、首先禁用分片自动分配(先暂停集群的shard自动均衡) curl -XPUT http://127.0.0.1:9200/_cluster/settings -d '{ "transient" : { "cluster.routing.allocation.enable" : "none" ...
数据结构第四次试验：数组建立二叉树
sjx3161的博客
04-18 410
数据结构第四次试验：数组建立二叉树前言一、实验内容第147页第三题第一小题第147页第三题第三小题二、实验环境三、实验目的四、算法设计五、实验代码六、实验结果截图七、实验分析（选做） 前言 为了帮助同学们完成痛苦的实验课程设计，本作者将其作出的实验结果及代码贴至CSDN中，供同学们学习参考。如有不足或描述不完善之处，敬请各位指出，欢迎各位的斧正！ 一、实验内容 第147页第三题第一小题 统计二叉树的叶结点个数 第147页第三题第三小题 交换二叉树每个节点的左孩子和右孩子 二、实验环境 Dev C++或Vis
静态建立二叉树 数据结构 C语言实现
Tokai_teiorunner的博客
02-25 504
下列代码要创建一个上图所示的二叉树（静态建立，如果要实现动态建立要用到递归，那个我还没学） 我们下面要建立的二叉树比较低级，就一个初始化和一个先序遍历的功能。 以后我学会的其他二叉树的操作一定会以一个萌新的视角分享自己的理解给大家，希望大佬们多多包涵。 先序遍历是先访问根节点然后访问左子树和右子树的一种二叉树的遍历方式。 另外二叉树还有另外两种遍历方式，中序遍历和后序遍历。 中序遍历是先访问左子树再访问根节点再访问右子树。 后续遍历是先访问左子树再访问右子树再访问根节点。 要确定一棵二叉树..
《数据结构之树篇》--二叉树的数组实现
WingC的博客
04-22 292
--头文件： #pragma once #ifndef TREE_H_ #define TREE_H_ #include using namespace std; class Tree { public: Tree(int size,int *pRoot); ~Tree(); int *SearchNode(int nodeIndex); bool AddNode(int nodeI
头歌数据结构二叉树的顺序存储及基本操作
05-18
总的来说，顺序存储的二叉树是一种简化了内存管理的数据结构，适用于静态二叉树或已知结构的二叉树，它可以简化存储和遍历操作，但灵活性较低。在实际应用中，我们还需要考虑其他存储方式，如链式存储，以适应更复杂...
静态链表 2 结构体数组的实现
just_tanks的博客
09-30 486
之前通过数组实现的，现在用结构体数组实现的，关键是结构体数组，然后写好分配及回收算法就行了//结构体数组 typedef struct { int data; int cur; }component,slink[MAXSIZE];/* * newlink.c * * Created on: 2017-9-29 * Author: Administrator */
java求一颗二叉树从根到叶子节点之和的最大值及二叉树的遍历
老狼的博客
09-29 2031
求一颗二叉树从根到叶子节点之和的最大值 比如: 1 2 3 4 1 6 分支分别是: 1+2+4=7 1+2+1=4 1+3+6=10 所以最大值是10 大体思路 将根到叶子节点所有路径的值求出来,然后分别计算每条路径的和进行比较,得出最大值, 第一步: 求出根到叶子节点路径的集合 public static void findPath(Node node, List<List&...
c语言将二叉树转换成数组,C语言 将二叉树转化为静态数组
weixin_39878716的博客
05-21 343
C语言 将二叉树转化为静态数组 (4页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！9.9 积分//C语言，将动态二叉树转化为静态数组#include#include//建立二叉树struct treenode *createBiTree(struct treenode **p,int x);//显示二叉树void traverse(struct tr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值