数据结构(5.4_2)——树和森林的遍历

最新推荐文章于 2024-08-06 23:37:06 发布
最新推荐文章于 2024-08-06 23:37:06 发布
阅读量936 收藏 7
点赞数 16
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65240792/article/details/140890888
版权

 树的先根遍历(深度优先遍历) 

若树非空，先访问根结点，再依次对每棵子树进行先根遍历

树的先根遍历序列和这棵树相应二叉树的先序序列相同。  

伪代码：

//树的先根遍历
void PreOrder(TreeNode* R) {
    if (R != NULL) {
        visit(R);//访问根结点
        while(R还有下一个子树T)
            PreOrder(T)//先根遍历下一棵子树
    }
}

实例：

#include <stdio.h>

// 定义树节点的结构体（兄弟兄弟表示法）
typedef struct CSNode {
    int data;                   // 节点存储的数据
    struct CSNode* firstchild; // 指向第一个子节点的指针
    struct CSNode* nextsibling; // 指向右兄弟节点的指针
} CSNode, *CSTree;

// 创建一个新树节点
CSNode* createTreeNode(int value) {
    CSNode* newNode = (CSNode*)malloc(sizeof(CSNode));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = value;
    newNode->firstchild = NULL;
    newNode->nextsibling = NULL;
    return newNode;
}

// 向树节点添加子节点
void addChild(CSTree parent, CSTree child) {
    if (parent == NULL || child == NULL) {
        return;
    }
    if (parent->firstchild == NULL) {
        parent->firstchild = child;
    } else {
        CSTree current = parent->firstchild;
        while (current->nextsibling != NULL) {
            current = current->nextsibling;
        }
        current->nextsibling = child;
    }
}

// 访问节点
void visit(CSNode* node) {
    if (node != NULL) {
        printf("%d ", node->data);
    }
}

// 先根遍历
void PreOrder(CSTree R) {
    if (R != NULL) {
        visit(R); // 访问根节点
        CSTree current = R->firstchild;
        while (current != NULL) {
            PreOrder(current); // 先根遍历子树
            current = current->nextsibling; // 移动到下一个兄弟节点
        }
    }
}

// 释放树的内存
void freeTree(CSTree root) {
    if (root == NULL) {
        return;
    }
    CSTree current = root->firstchild;
    while (current != NULL) {
        CSTree temp = current;
        current = current->nextsibling;
        freeTree(temp);
    }
    free(root);
}

// 主函数示例
int main() {
    // 创建树节点
    CSTree root = createTreeNode(1);
    CSTree child1 = createTreeNode(2);
    CSTree child2 = createTreeNode(3);
    CSTree child3 = createTreeNode(4);
    CSTree child4 = createTreeNode(5);
    CSTree child5 = createTreeNode(6);

    // 构建树结构
    addChild(root, child1);
    addChild(root, child2);
    addChild(child1, child3);
    addChild(child1, child4);
    addChild(child2, child5);

    // 执行先根遍历
    printf("Pre-order traversal of the tree is: ");
    PreOrder(root);
    printf("\n");

    // 释放树占用的内存
    freeTree(root);

    return 0;
}

 我们首先创建了一个树，然后通过 addChild 函数将子节点添加到其父节点。PreOrder 函数按照先根遍历的顺序访问每个节点。最后，我们通过 freeTree 函数释放了整个树所占用的内存。在主函数 main 中，我们构建了一个具体的树结构，并执行了先根遍历。

树的后根遍历 (深度优先遍历)

若树非空，先依次对每棵子树进行后根遍历，最后再访问根结点

树的后根遍历序列和这棵树相应二叉树的中序序列相同。   

伪代码：

//树的后根遍历
void PostOrder(TreeNode* R) {
    if (R != NULL) {
        while (R还有下一个子树T)
            PostOrder(T)//后根遍历下一棵子树
        visit(R);//访问根结点    
    }
}

实例：

#include <stdio.h>

// 定义树节点的结构体（兄弟兄弟表示法）
typedef struct CSNode {
    int data;                   // 节点存储的数据
    struct CSNode* firstchild; // 指向第一个子节点的指针
    struct CSNode* nextsibling; // 指向右兄弟节点的指针
} CSNode, *CSTree;

// 创建一个新树节点
CSNode* createTreeNode(int value) {
    CSNode* newNode = (CSNode*)malloc(sizeof(CSNode));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = value;
    newNode->firstchild = NULL;
    newNode->nextsibling = NULL;
    return newNode;
}

// 向树节点添加子节点
void addChild(CSTree parent, CSTree child) {
    if (parent == NULL || child == NULL) {
        return;
    }
    if (parent->firstchild == NULL) {
        parent->firstchild = child;
    } else {
        CSTree current = parent->firstchild;
        while (current->nextsibling != NULL) {
            current = current->nextsibling;
        }
        current->nextsibling = child;
    }
}

// 访问节点
void visit(CSNode* node) {
    if (node != NULL) {
        printf("%d ", node->data);
    }
}

// 后根遍历
void PostOrder(CSTree R) {
    if (R != NULL) {
        CSTree current = R->firstchild;
        while (current != NULL) {
            PostOrder(current); // 后根遍历子树
            current = current->nextsibling; // 移动到下一个兄弟节点
        }
        visit(R); // 访问根节点
    }
}

// 释放树的内存
void freeTree(CSTree root) {
    if (root == NULL) {
        return;
    }
    CSTree current = root->firstchild;
    while (current != NULL) {
        CSTree temp = current;
        current = current->nextsibling;
        freeTree(temp);
    }
    free(root);
}

// 主函数示例
int main() {
    // 创建树节点
    CSTree root = createTreeNode(1);
    CSTree child1 = createTreeNode(2);
    CSTree child2 = createTreeNode(3);
    CSTree child3 = createTreeNode(4);
    CSTree child4 = createTreeNode(5);
    CSTree child5 = createTreeNode(6);

    // 构建树结构
    addChild(root, child1);
    addChild(root, child2);
    addChild(child1, child3);
    addChild(child1, child4);
    addChild(child2, child5);

    // 执行后根遍历
    printf("Post-order traversal of the tree is: ");
    PostOrder(root);
    printf("\n");

    // 释放树占用的内存
    freeTree(root);

    return 0;
}

我们首先创建了一个树，然后通过 addChild 函数将子节点添加到其父节点。PostOrder 函数按照后根遍历的顺序访问每个节点。首先递归地遍历所有子树，然后访问根节点。最后，我们通过 freeTree 函数释放了整个树所占用的内存。在主函数 main 中，我们构建了一个具体的树结构，并执行了后根遍历。

树的层次遍历 (广度优先遍历)

用队列实现：

  1. 若树非空，则根节点入队
  2. 若队列非空，队头元素出队并访问，同时将该元素的孩子依次入队
  3. 重复2直到队列为空

伪代码：

// 树的层次遍历
void LevelOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    
    // 创建一个队列，用于存储待访问的节点
    Queue queue;
    initializeQueue(&queue);
    
    // 将根节点入队
    enqueue(queue, root);
    
    // 当队列不为空时，继续遍历
    while (!isEmpty(queue)) {
        // 出队一个节点
        TreeNode* current = dequeue(queue);
        
        // 访问当前节点
        visit(current);
        
        // 获取当前节点的所有子节点
        TreeNode* child = current->firstchild;
        
        // 遍历当前节点的所有子节点
        while (child != NULL) {
            enqueue(queue, child);
            child = child->nextsibling;
        }
    }
}

// 辅助函数：初始化队列
void initializeQueue(Queue* queue) {
    queue->front = NULL;
    queue->rear = NULL;
}

// 辅助函数：队列是否为空
bool isEmpty(Queue queue) {
    return queue.front == NULL;
}

// 辅助函数：将节点入队
void enqueue(Queue* queue, TreeNode* node) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    if (newNode == NULL) {
        // 处理内存分配失败的情况
    }
    newNode->node = node;
    newNode->next = NULL;
    
    if (queue->rear == NULL) {
        queue->front = newNode;
    } else {
        queue->rear->next = newNode;
    }
    queue->rear = newNode;
}

// 辅助函数：从队列中出队一个节点
TreeNode* dequeue(Queue* queue) {
    if (isEmpty(*queue)) {
        return NULL;
    }
    
    TreeNode* frontNode = queue->front->node;
    QueueNode* temp = queue->front;
    queue->front = queue->front->next;
    
    if (queue->front == NULL) {
        queue->rear = NULL;
    }
    
    free(temp);
    return frontNode;
}

 代码实例：

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

// 定义树节点的结构体（兄弟兄弟表示法）
typedef struct CSNode {
    int data;                   // 节点存储的数据
    struct CSNode* firstchild; // 指向第一个子节点的指针
    struct CSNode* nextsibling; // 指向右兄弟节点的指针
} CSNode, *CSTree;

// 创建一个新树节点
CSNode* createTreeNode(int value) {
    CSNode* newNode = (CSNode*)malloc(sizeof(CSNode));
    if (newNode == NULL) {
        fprintf(stderr, "Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }
    newNode->data = value;
    newNode->firstchild = NULL;
    newNode->nextsibling = NULL;
    return newNode;
}

// 向树节点添加子节点
void addChild(CSTree parent, CSTree child) {
    if (parent == NULL || child == NULL) {
        return;
    }
    if (parent->firstchild == NULL) {
        parent->firstchild = child;
    } else {
        CSTree current = parent->firstchild;
        while (current->nextsibling != NULL) {
            current = current->nextsibling;
        }
        current->nextsibling = child;
    }
}

// 访问节点
void visit(CSNode* node) {
    if (node != NULL) {
        printf("%d ", node->data);
    }
}

// 层次遍历
void LevelOrder(CSTree root) {
    if (root == NULL) {
        return;
    }
    CSTree current = root;
    bool isRoot = true;
    while (current != NULL) {
        if (isRoot) {
            visit(current); // 访问根节点
            isRoot = false;
        }
        CSTree temp = current->firstchild;
        while (temp != NULL) {
            visit(temp); // 访问当前节点的所有子节点
            temp = temp->nextsibling;
        }
        current = current->nextsibling; // 移动到下一个兄弟节点
    }
}

// 释放树的内存
void freeTree(CSTree root) {
    if (root == NULL) {
        return;
    }
    CSTree current = root->firstchild;
    while (current != NULL) {
        CSTree temp = current;
        current = current->nextsibling;
        freeTree(temp);
    }
    free(root);
}

// 主函数示例
int main() {
    // 创建树节点
    CSTree root = createTreeNode(1);
    CSTree child1 = createTreeNode(2);
    CSTree child2 = createTreeNode(3);
    CSTree child3 = createTreeNode(4);
    CSTree child4 = createTreeNode(5);
    CSTree child5 = createTreeNode(6);

    // 构建树结构
    addChild(root, child1);
    addChild(root, child2);
    addChild(child1, child3);
    addChild(child1, child4);
    addChild(child2, child5);

    // 执行层次遍历
    printf("Level-order traversal of the tree is: ");
    LevelOrder(root);
    printf("\n");

    // 释放树占用的内存
    freeTree(root);

    return 0;
}

我们首先创建了一个树，然后通过 addChild 函数将子节点添加到其父节点。LevelOrder 函数按照层次遍历的顺序访问每个节点。首先将根节点入队，然后在循环中不断从队列中出队节点并访问它，然后将它的所有子节点入队。当队列为空时，遍历结束。最后，我们通过 freeTree 函数释放了整个树所占用的内存。在主函数 main 中，我们构建了一个具体的树结构，并执行了层次遍历。 

 森林。森林是m(m>=0)棵互不相交的树的集合。每棵树去掉根节点后，其各个子树又组成森林。

森林的先序遍历

若森林非空，则按如下规则进行遍历：

  1. 访问森林中第一棵树的根结点
  2. 先序遍历第一棵树中根结点的子树森林
  3. 先序遍历除去第一棵树之后剩余的树构成的森林

森林的先序遍历等于依次对各个树进行先根遍历 

方法二：将森林先转换成二叉树进行先序遍历

森林的中序遍历 

若森林非空，则按如下规则进行遍历：

  1. 中序遍历第一棵树中根结点的子树森林
  2. 访问森林中第一棵树的根结点
  3. 中序遍历除去第一棵树之后剩余的树构成的森林

森林的中序遍历等于依次对各个树进行后根遍历  

方法二：将森林先转换成二叉树进行中序遍历

总结：

 

野草y
关注
  • 16
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构系列文章目录
qq_31804097的博客
08-06 361
按章节顺序更新 望三连。
数据结构（邓俊辉）学习笔记】词典 03—— 排解冲突(1)
weixin_44399845的博客
08-06 453
学习下词条的排解冲突方法
重生之我 学习【数据结构之顺序表（SeqList）】
xupy019的博客
08-06 770
全新的开始，为大家带来数据结构的内容（C语言实现）将以顺序表、链表、栈区、队列、二叉树、常见排序算法为主要内容展开学习
数据结构2:C++基于二叉堆实现优先队列
LorraineWen的博客
08-03 543
C++通过二叉堆实现优先队列
暑期数据结构 空间复杂度
最新发布
Starry_tsx的博客
08-06 467
空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。这个地方我们看箭头4和5，我们先执行函数Fib(3)使用完之后函数空间还给系统，但是执行Fib(4)本质上再开辟的那个空间还是和Fib(3)一样的。原因在于我们使用函数时会开辟一片空间，函数结束时会将那片空间还给系统 ，但是下次另一个函数使用时开辟的那个空间还是原来函数的。要计算Fib(N - 1)就要先算Fib(N - 2)+Fib(N -3 )要先计算Fib(N - 1)再计算Fib(N - 2);
数据结构之《二叉树》(中)
2303_81098358的博客
08-03 860
中学习了树的相关概念，还了解的树中的二叉树的顺序结构和链式结构，在本篇中我们将重点学习二叉树中的堆的相关概念与性质，同时试着实现堆中的相关方法，一起加油吧！
咒语和药水的成功对数
weixin_45092290的博客
08-05 557
本题解提供了一种方法，通过排序和二分搜索优化法术和药水的成功配对计算过程。首先对药水数组进行排序，然后对每个法术计算达到成功阈值所需的最小药水效力，并利用lower_bound快速定位满足条件的药水。通过计算满足条件的药水数量，我们可以高效地为每个法术找到成功的配对药水数目。此方法结合了计算效率和实用性，适合处理大规模数据。
暑期数据结构 时间复杂度
Starry_tsx的博客
08-06 319
个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。但是实际中我们计算时间复杂度时，我们其实并不一定要计算精度的执行次数，而只需要大概执行次数，那么这里我们使用O的渐进表示法。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。比如说如果函数是F(N)=N*N+N+4,那么当N无限大的时候，对F(N）产生主要影响的是N*N。比如说如果函数是F(N)=N+4,那么当N无限大的时候，对F(N）产生主要影响的是N。
数据结构：堆
AWSDN的博客
08-06 660
本文主要介绍数据结构中堆的知识
树与二叉树、图的基本概念
kusunoki的博客
08-06 377
记录树与二叉树、图的基本概念和性质，便于回忆和查阅。
【数据结构入门 】队列
KevinRay_0854的博客
08-03 759
队列在计算机科学中广泛应用，例如任务调度、消息传递、缓冲区管理等领域。在编程中，队列通常使用数组或链表来实现。
王道数据结构 | 第二章 线性表
emmm_Yeah的博客
07-31 708
王道数据结构整理 第二章线性表 顺序表 单链表 双链表 循环单/双链表 静态链表
hashmap底层原理(数据结构 put原理 get原理 remove原理)
qq_52897007的博客
08-06 444
HashMap 数据结构为，其中：链表的节点存储的是一个 Entry 对象，每个Entry 对象存储四个属性HashMap实现采用Entry数组来存储key-value对(数组默认大小为0)，每一个键值对组成了一个Entry实体，Entry类实际上是一个单向的链表结构，它具有Next指针，可以连接下一个Entry实体JDK1.8 版本的HashMap，底层数据使用数组 + 链表/实现。满足链表长度超过8且数组长度大于64，才会将链表替换成红黑树才会树化。
数据结构与算法-15高级数据结构_树论（堆树）
qq_40469712的博客
08-02 883
定义：堆树是一种特殊的完全二叉树，其中每个节点的值都遵循一定的堆属性。具体来说，堆分为最大堆和最小堆。最大堆：在最大堆中，每个父节点的值都大于或等于其任何子节点的值。这意味着根节点是树中的最大值。最小堆：在最小堆中，每个父节点的值都小于或等于其任何子节点的值。这意味着根节点是树中的最小值。完全二叉树：除了最后一层外，每一层都被完全填满，且所有节点都尽可能地向左对齐。这种结构使得堆可以用数组来高效地表示和实现。
《数据结构》（C语言版）第1章 绪论（下）
m0_70617423的博客
07-31 1225
抽象数据类型的表示与实现 算法与算法分析
征服数据结构中的时间和空间复杂度
m0_51821434的博客
08-03 1063
本篇文章主要对数据结构中的时间复杂度和空间复杂度进行了讲解
数据结构：基于顺序表实现通讯录系统（含源码）
2401_86551514的博客
08-01 435
上一篇我们讲了如何实现动态顺序表，这一篇就基于顺序表实现通讯录系统，我们知道顺序表的底层逻辑其实就是数组，同样的，通讯录系统也只是在顺序表之上进行了一层封装，相当于把每一个用户的所以数据都当做了数组中的一个元素，在通过顺序表的增删查改功能实现通讯录相对应的功能。每个数组元素中都包含这样整个的用户数据功能要求：1.能够保存用户信息：名字、性别、年龄、电话、地址等2.增加联系人信息3.删除指定联系人4.查找制定联系人5.修改指定联系人6.显示联系⼈信息。
【数据结构】——堆的实现（赋源码）
ZWW_zhangww的博客
08-06 307
堆(Heap)是中一类特殊的，是最高效的。堆通常是一个可以被看作一棵的数组对象。
数据结构第九讲：二叉树
2301_79761834的博客
08-03 717
数据结构第九讲：二叉树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值