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

最新推荐文章于 2023-09-14 17:19:12 发布
最新推荐文章于 2023-09-14 17:19:12 发布
阅读量838 收藏 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
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-第五期——二叉树（Python）
荷叶田田的博客
12-21 3850
二叉树满足条件：1、本身是有序树 2、树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2；
数据结构之二叉树(数组)
qq_36691402的博客
08-06 313
二叉树的定义 　　二叉树(binary tree)由结点的有限集合构成，这个有限集合或者为空集(empty)，或者为由一个根结点(root)及两棵互不相交、分别称作这个根的左子树(left subtree)和右子树(right subtree)的二叉树组成的集合。 二叉树的五种基本形态 二叉树相关术语 p二叉树是由唯一的起始结点引出的结点集合
静态二叉树
Harington的博客
02-28 471
不会用指针的也能实现二叉树（静态二叉树）数组实现。 struct node{ int data; int lchild; int rchild; }Node[maxn]; int index = 0; int newNode(int v){ Node[index].data = v; Node[index].lchild = -1; Node[index].rchild = ...
elasticsearch集群节点滚动重启操作流程
wer的博客
09-19 1698
操作前，停掉所有写入操作（重要）；然后到head插件索引 动作操作中，点击flush刷新菜单（flush是落盘操作，将暂时写入es内存的数据刷入磁盘，防止内存中少量的数据丢失） 1、首先禁用分片自动分配(先暂停集群的shard自动均衡) curl -XPUT http://127.0.0.1:9200/_cluster/settings -d '{ "transient" : { "cluster.routing.allocation.enable" : "none" ...
数据结构(12)--二叉树的静态链表存储和遍历的实现
热门推荐
小白的专栏
02-29 1万+
参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 1.二叉树的定义 二叉树(Binary Tree)是结点的有限集合，这个集合或者是空，或者是由一个根结点和两棵互不相交的称为左子树和右子树的二叉树构成。 以上对二叉树的定义也是一种递归的方式，二叉树...
按数组顺序创建一个完全二叉树
axyzstra 的博客
02-14 2470
按照数组顺序插入到二叉树中 参考文章 数组与二叉树的对应关系：一个结点在数组中的序号为 i，则其左孩子结点序号为 2 * i，右孩子结点序号为 2 * i + 1； 根据这条关系，我们可以建立个按照数组顺序的二叉树； /* 将数组 arr 按照顺序建立二叉树，i 为当前插入元素在数组中的位置，n 为数组元素个数，root 为本次插入的结点地址；这个函数的左右是将数组中 arr[i] 元素插入到地址为 root 的位置上，那么结点 root 的左孩子结点插入元素为 arr[2 * i]，右孩子结点插入元素为
《数据结构之树篇》--二叉树的数组实现
WingC的博客
04-22 266
--头文件： #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
C语言数据结构代码-包含所有常用数据结构实现方式
12-02
数组是一种静态数据结构，元素在内存中连续存储，而链表则是动态数据结构，通过指针连接元素。这个压缩包可能包含了顺序表（数组实现）和链表（单链表、双链表）的创建、插入、删除、遍历等操作的代码示例。 2. **...
沈阳工业大学-数据结构-期末复习.pdf
12-31
* 数据结构的分类：数组、链表、树、图等 * 数据结构的特点：逻辑结构、存储结构、运算结构 二、数组和链表 * 数组是一种线性存储结构，元素在内存中连续存放 * 链表是一种动态存储结构，元素在内存中不连续存放 *...
C语言和cpp实现的数据结构
最新发布
01-02
C语言是一种底层、静态类型的编程语言，它的语法简洁，执行效率高，特别适合实现底层的数据结构。C语言提供的指针操作使得直接操控内存成为可能，这对于创建动态数据结构如链表、树等非常有利。例如，你可以使用...
二叉树 动态链表转化为静态结构数组
06-03
在编这个程序之前 其实在网上搜了很多这方面对于这个方法实现的程序 可没找到 于是自己编了一个 结构思路很容易看清楚 希望对大家有帮助
用先序次序输入结点建立二叉树，并输出二叉树的中序序列
10-26
最简单的二叉树建立的程序，比较适合初学者，可作为初学者的树与二叉树的第一个程序！
数据结构-何钦铭、陈越 课件资源
06-15
- 静态和动态数据结构的选择。 - 排序和搜索算法，如冒泡排序、选择排序、插入排序、快速排序、归并排序、二分查找等。 - 常见问题的解决方案，如堆排序在优先队列中的应用，图的遍历算法（深度优先搜索和广度优先...
数据结构C++-任燕.zip
12-24
这个名为"数据结构C++-任燕.zip"的压缩包文件显然包含了任燕教授或作者关于数据结构使用C++实现的源代码和相关材料，特别是与第11章有关的内容。 在C++中，数据结构的实现通常涉及以下几个关键概念： 1. **数组**...
CPPDay016[算法与数据结构] 数组实现完全二叉树
坚持硬核
09-06 436
目录 0x00 先序，后序，中序遍历的相互推导： 0x01满二叉树： 1.定义： 2.特性： 0x02完全二叉树： 1.定义： 2.特性： 0x03 完全二叉树的增删查改 0x00 先序，后序，中序遍历的相互推导： 已知先序和中序可以推导出后序，已知中序和后序可以推导出先序，但是已知先序和后序却推导不出中序。例如：有一颗树如下： 先序遍历：ABDEGCFH 中序遍历...
数据结构与算法：利用数组实现完全二叉树（C++）
weixin_44928892的博客
10-31 1465
任务：使用C++语言，通过数组的形式来实现一颗平衡二叉树，包括树的创建，添加结点，查找结点，删除结点等功能。 main.cpp 代码如下： #include "CompleteBinaryTree.h" int main() { CompleteBinaryTree<char> tree; for (int i = 0; i < 10; i++) { tree.Add('A' + i); } cout << "先
满二叉树的数组表示
tonystk123的博客
06-14 384
2^D - 1. D 的意思是二叉树的高度, 比如当 D = 1 时, 二叉树只有一个节点, 当 D = 2 时, 二叉树有两层, 节点为1, 2, 3, 当 D = 3 时, 节点为 1, 2, 3, 4, 5, 6, 7. 以此类推. 在节点 1 处放一个小球, 它会往下落. 每个内节点上都有一个开关, 初始全部关闭, 当每次有小球落到一个开关上时, 它的状态都会改变. 当小球到达一个内节点时, 如果该节点上的开关关闭, 则往左走, 否则往右走, 直到走到叶子节点.主要是理解二叉树的数组表示。
C++数据结构：二叉树之一（数组存储）
攻城狮的博客
05-30 2893
树是一种非线性数据结构，它由若干个节点和边组成。每个节点都有一个值，而边则表示节点之间的关系。树具有层次结构，其中一个节点被称为根节点，它没有父节点。除根节点外，每个节点都有且仅有一个父节点。树的基本性质包括树的深度、高度、度数等。森林是由若干棵互不相交的树组成的集合。一棵树可以看作是一个仅包含一棵树的森林。二叉树是一种特殊的树，它的每个节点最多只有两个子节点，分别称为左子节点和右子节点。二叉树是树的一种特殊形式，它具有树的所有基本性质，同时还有一些独特的性质。
静态链表（数组）表示二叉树
LCK_jack的博客
09-14 260
我们将所有节点储存在一个包含特殊数组（数组元素包括：节点数据、两个节点下表）中，将对应左右子节点的下标存放在数组中，没有子节点则设置为-1。这样，当我们遍历完所有节点后发现没有出现的数字所对应的数组元素就是根节点，而且通过储存所有子节点的下标也可以唯一的确定一棵树。我们可以采用静态链表的方式来进行储存，从而直观的找出根节点的位置。上体所述，我们要怎么求出这棵树的根节点呢？
杭州电子科技大学数据结构课件chap3(与“查找”相关共151张).pptx
12-02
为了提高查找效率，通常会使用某种数据结构来组织查找表，比如有序数组、二叉搜索树、平衡树等。这些结构通过人为地添加关系，使查找过程更有效率。查找方法的选择直接影响到查找效率，因此在设计数据结构时，需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值