数据结构之多叉树c实现DFS和BFS

最新推荐文章于 2024-08-20 14:41:36 发布
最新推荐文章于 2024-08-20 14:41:36 发布
阅读量5.7k 收藏 8
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构 bfs dfs

原文地址：
http://www.cnblogs.com/unixfy/p/3486179.html

文本文件内容：

aA 4 g cC z bBbB
z 2 f i
g 1 d
d 3 x e j
#include<stdio.h>
#include <stdlib.h>
#include <string.h>

#define MaxLenOfName 101

//定义多叉书结点结构体
typedef struct node
{
    //节点名
    char* name;
    //子节点个数
    int n_children;
    //记录该节点在多叉树中的层数
    int level;
    // 指向其自身的子节点，children一个数组，该数组中的元素时node_t*指针
    struct node** children;
}NODE;// 对结构体重命名

      // 实现一个栈，用于后续操作
typedef struct stack_t
{
    NODE** array; // array是个数组，其元素为NODE*型指针
    int    index; // 指示栈顶元素
    int    size;  // 栈的大小
} STACK; // 重命名

         // 实现一个队列，用于后续操作
typedef struct queue_t
{
    NODE** array; // array是个数组，其内部元素为NODE*型指针
    int    head;  // 队列的头
    int    tail;  // 队列的尾
    int    num;   // 队列中元素的个数
    int    size;  // 队列的大小
} QUEUE;

// 这里的栈和队列，都是用动态数组实现的，另一种实现方式是用链表


// 内存分配函数
void* util_malloc(int size)
{
    void* ptr = malloc(size);

    if (ptr == NULL) // 如果分配失败，则终止程序
    {
        printf("Memory allocation error!\n");
        exit(EXIT_FAILURE);
    }

    // 分配成功，则返回
    return ptr;
}

// 字符串赋值函数
// 对strdup函数的封装，strdup函数直接进行字符串赋值，不用对被赋值指针分配空间
// 比strcpy用起来方便，但其不是标准库里面的函数
// 用strdup函数赋值的指针，在最后也是需要free掉的
char* util_strdup(char* src)
{
    char* dst = _strdup(src);

    if (dst == NULL) // 如果赋值失败，则终止程序
    {
        printf("Memroy allocation error!\n");
        exit(EXIT_FAILURE);
    }

    // 赋值成功，返回
    return dst;
}

// 对fopen函数封装
FILE* util_fopen(char* name, char* access)
{
    FILE* fp = fopen(name, access);

    if (fp == NULL) // 如果打开文件失败，终止程序
    {
        printf("Error opening file %s!\n", name);
        exit(EXIT_FAILURE);
    }

    // 打开成功，返回
    return  fp;
}

// 实现一些栈操作

// 栈的初始化
STACK* STACKinit(int size) // 初始化栈大小为size
{
    STACK* sp;

    sp = (STACK*)util_malloc(sizeof(STACK));
    sp->size = size;
    sp->index = 0;
    sp->array = (NODE**)util_malloc(size * sizeof(NODE*));

    return sp;
}

// 检测栈是否为空
// 如果为空返回1，否则返回0
int STACKempty(STACK* sp)
{
    if (sp == NULL || sp->index <= 0) // 空
    {
        return 1;
    }
    return 0;
}

// 压栈操作
int STACKpush(STACK* sp, NODE* data)
{
    if (sp == NULL || sp->index >= sp->size) // sp没有被初始化，或者已满
    {
        return 0; // 压栈失败
    }

    sp->array[sp->index++] = data; // 压栈
    return 1;
}

// 弹栈操作
int STACKpop(STACK* sp, NODE** data_ptr)
{
    if (sp == NULL || sp->index <= 0) // sp为初始化，或者为空没有元素
    {
        return 0;
    }

    *data_ptr = sp->array[--sp->index]; // 弹栈
    return 1;
}

// 将栈消毁
void STACKdestroy(STACK* sp)
{
    free(sp->array);
    free(sp);
}
// 以上是栈的操作

// 实现队列的操作
QUEUE* QUEUEinit(int size)
{
    QUEUE* qp;

    qp = (QUEUE*)util_malloc(sizeof(QUEUE));
    qp->size = size;
    qp->head = qp->tail = qp->num = 0;
    qp->array = (NODE**)util_malloc(size * sizeof(NODE*));

    return qp;
}

// 入队列
int QUEUEenqueue(QUEUE* qp, NODE* data)
{
    if (qp == NULL || qp->num >= qp->size) // qp未初始化或已满
    {
        return 0; // 入队失败
    }

    qp->array[qp->tail] = data; // 入队，tail一直指向最后一个元素的下一个位置
    qp->tail = (qp->tail + 1) % (qp->size); // 循环队列
    ++qp->num;
    return 1;
}

// 出队列
int QUEUEdequeue(QUEUE* qp, NODE** data_ptr)
{
    if (qp == NULL || qp->num <= 0) // qp未初始化或队列内无元素
    {
        return 0;
    }

    *data_ptr = qp->array[qp->head]; // 出队
    qp->head = (qp->head + 1) % (qp->size); // 循环队列
    --qp->num;

    return 1;
}

// 检测队列是否为空
int QUEUEempty(QUEUE* qp)
{
    if (qp == NULL || qp->num <= 0)
    {
        return 1;
    }

    return 0;
}

// 销毁队列
void QUEUEdestroy(QUEUE* qp)
{
    free(qp->array);
    free(qp);
}
// 以上是队列的有关操作实现

// 生成多叉树节点
NODE* create_node()
{
    NODE* q;

    q = (NODE*)util_malloc(sizeof(NODE));
    q->n_children = 0;
    q->level = -1;
    q->children = NULL;

    return q;
}

// 按节点名字查找
NODE* search_node_r(char name[MaxLenOfName], NODE* head)
{
    NODE* temp = NULL;
    int i = 0;

    if (head != NULL)
    {
        if (strcmp(name, head->name) == 0) // 如果名字匹配
        {
            temp = head;
        }
        else // 如果不匹配，则查找其子节点
        {
            for (i = 0; i < head->n_children && temp == NULL/*如果temp不为空，则结束查找*/; ++i)
            {
                temp = search_node_r(name, head->children[i]); // 递归查找子节点
            }
        }
    }

    return temp; // 将查找到的节点指针返回，也有可能没有找到，此时temp为NULL
}


// 从文件中读取多叉树数据，并建立多叉树
void read_file(NODE** head, char* filename)
{
    NODE* temp = NULL;
    int i = 0, n = 0;
    char name[MaxLenOfName], child[MaxLenOfName];
    FILE* fp;

    fp = util_fopen(filename, "r"); // 打开文件

    while (fscanf(fp, "%s %d", name, &n) != EOF) // 先读取节点名字和当前节点的子节点个数
    {
        if (*head == NULL) // 若为空
        {
            temp = *head = create_node();   // 生成一个新节点
            temp->name = util_strdup(name); // 赋名
        }
        else
        {
            temp = search_node_r(name, *head); // 根据name找到节点
                                               // 这里默认数据文件是正确的，一定可以找到与name匹配的节点
                                               // 如果不匹配，那么应该忽略本行数据
        }
        // 找到节点后，对子节点进行处理
        temp->n_children = n;
        temp->children = (NODE**)malloc(n * sizeof(NODE*));
        if (temp->children == NULL) // 分配内存失败
        {
            fprintf(stderr, "Dynamic allocation error!\n");
            exit(EXIT_FAILURE);
        }

        // 如果分配成功，则读取后面的子节点，并保存
        for (i = 0; i < n; ++i)
        {
            fscanf(fp, "%s", child); // 读取子节点
            temp->children[i] = create_node(); // 生成子节点
            temp->children[i]->name = util_strdup(child); // 读子节点赋名
        }
    }

    // 读取完毕，关闭文件
    fclose(fp);
}

// 实现函数1
// 将多叉树中的节点，按照深度进行输出
// 实质上实现的是层次优先遍历
void f1(NODE* head)
{
    NODE* p = NULL;
    QUEUE* q = NULL; // 定义一个队列
    STACK* s = NULL; // 定义一个栈
    int i = 0;

    q = QUEUEinit(100); // 将队列初始化大小为100
    s = STACKinit(100); // 将栈初始化大小为100

    head->level = 0; // 根节点的深度为0

                     // 将根节点入队列
    QUEUEenqueue(q, head);

    // 对多叉树中的节点的深度值level进行赋值
    // 采用层次优先遍历方法，借助于队列
    while (QUEUEempty(q) == 0) // 如果队列q不为空
    {
        QUEUEdequeue(q, &p); // 出队列
        for (i = 0; i < p->n_children; ++i)
        {
            p->children[i]->level = p->level + 1; // 对子节点深度进行赋值：父节点深度加1
            QUEUEenqueue(q, p->children[i]);      // 将子节点入队列
        }
        STACKpush(s, p); // 将p入栈
    }

    while (STACKempty(s) == 0) // 不为空
    {
        STACKpop(s, &p); // 弹栈
        fprintf(stdout, "   %d %s\n", p->level, p->name);
    }

    QUEUEdestroy(q); // 消毁队列
    STACKdestroy(s); // 消毁栈
}

// 我的实现函数1
// 将多叉树中的节点，按照深度进行输出
// 实质上实现的是层次优先遍历
void myf1(NODE* head)
{
    NODE* p = NULL;
    QUEUE* q = NULL; // 定义一个队列
    QUEUE* myQ = NULL;
    //STACK* s = NULL; // 定义一个栈
    int i = 0;

    q = QUEUEinit(100); // 将队列初始化大小为100
    myQ = QUEUEinit(100);
    //s = STACKinit(100); // 将栈初始化大小为100

    head->level = 0; // 根节点的深度为0

                     // 将根节点入队列
    QUEUEenqueue(q, head);

    // 对多叉树中的节点的深度值level进行赋值
    // 采用层次优先遍历方法，借助于队列
    while (QUEUEempty(q) == 0) // 如果队列q不为空
    {
        QUEUEdequeue(q, &p); // 出队列
        for (i = 0; i < p->n_children; ++i)
        {
            p->children[i]->level = p->level + 1; // 对子节点深度进行赋值：父节点深度加1
            QUEUEenqueue(q, p->children[i]);      // 将子节点入队列
        }
        QUEUEenqueue(myQ, p);
        //STACKpush(s, p); // 将p入栈
    }

    while (!QUEUEempty(myQ))
    {
        QUEUEdequeue(myQ, &p);
        fprintf(stdout, "   %d %s\n", p->level, p->name);
    }
    //while (STACKempty(s) == 0) // 不为空
    //{
    //  STACKpop(s, &p); // 弹栈
    //  fprintf(stdout, "   %d %s\n", p->level, p->name);
    //}

    QUEUEdestroy(q); // 消毁队列
    QUEUEdestroy(myQ);
    //STACKdestroy(s); // 消毁栈
}

// 实现函数2
// 找到从根节点到叶子节点路径上节点名字字母个数最大的路径
// 实质上实现的是深度优先遍历
void f2(NODE* head, char* str, char** strBest, int level)
{
    int   i = 0;
    char* tmp = NULL;

    if (head == NULL)
    {
        return;
    }

    tmp = (char*)util_malloc((strlen(str) + strlen(head->name) + 1/*原程序中未加1*/) * sizeof(char));
    sprintf(tmp, "%s%s", str, head->name);

    if (head->n_children == 0)
    {
        if (*strBest == NULL || strlen(tmp) > strlen(*strBest))
        {
            free(*strBest);
            *strBest = util_strdup(tmp);
        }
    }

    for (i = 0; i < head->n_children; ++i)
    {
        f2(head->children[i], tmp, strBest, level + 1);
    }

    free(tmp);
}

// 消毁树
void free_tree_r(NODE* head)
{
    int i = 0;
    if (head == NULL)
    {
        return;
    }

    for (i = 0; i < head->n_children; ++i)
    {
        free_tree_r(head->children[i]);
    }

    free(head->name);
    // free(head->children); // 消毁子节点指针数组
    free(head);
}

int main(int argc, char* argv[])
{
    NODE* head = NULL;
    char* strBest = NULL;

    /*if (argc != 2)
    {
        fprintf(stderr, "Missing parameters!\n");
        exit(EXIT_FAILURE);
    }*/

    //read_file(&head, argv[1]);
    read_file(&head, "C:\\Users\\单凯\\Desktop\\data.txt");

    fprintf(stdout, "f1:\n");
    f1(head);

    fprintf(stdout, "myf1:\n");
    myf1(head);

    f2(head, "", &strBest, 0);
    fprintf(stdout, "f2:\n   %s\n", strBest);

    free_tree_r(head);

    return EXIT_SUCCESS;
}

结果：
这里写图片描述

kaikai_sk
关注
专栏目录
家谱图-多叉树-c语言-数据结构
04-24
本程序主要介绍使用c语言的树数据结构，比较全面的介绍和使用多叉树。
数据结构_简单的多叉树
迎难而上
10-10 3997
简单的多叉树，可以实现从叶子节点遍历到根 和 从根遍历叶子节点的过程： #include #include #include using namespace std; enum { SCHOOL, GRADE, CLASS }; class Node { public : Node():father(NULL),level(0) { ChildList.cl
C++知识点总结(50)：多叉树
joe_g12345的博客
07-22 1023
由于国家的数量十分庞大，道路的建造方案有很多种，同时每种方案的修建费用难以用人工计算，国王们决定找人设计一个软件，对于给定的建造方案，计算出所需要的费用。一般情况下，我们会将数据结构分为逻辑结构和物理结构，其中逻辑结构是我们的逻辑下存储的结构，而物理结构是计算机的逻辑下存储的结构。对于左子树（d g b），先序是（b d g），中序是（d g b）。对于右子树（e c h f），先序确定根是 c，中序确定 c 的左孩子是 e，右子树是（h f），推出 h 是 f 的左孩子。老师想了一会儿，给出了正解。
多叉树的实现
05-22
多叉树的实现，本算法采用5比较合适，纵向遍历靠递归调用
数据结构与算法(十四)之多叉树
qq_38783257的博客
02-26 1509
文章目录实现索引的方法B树b树的搜索b树的添加上溢b树的删除下溢B+树B+树的构建 实现索引的方法 使用hashmap实现索引就不能实现范围查询。 使用红黑树实现索引会存在树太高的情况，因为每查找一层就需要向磁盘发起一次请求，导致io消耗过大，消耗时间长，而且磁盘每个block是4k，使用红黑树存在空间浪费的现象。 这时候就需要更优的数据结构来存储数据，其中B树，B+树，B*树便是很好的一个选...
数据结构与算法——多叉树
最新发布
weixin_45942515的博客
08-20 264
1）二叉树需要加载到内存的，如果二叉树的节点少，没有什么问题，但是如果二叉树的节点很多(比如1亿)，就存在如下问题：2）问题1：在构建二叉树时，需要多次进行i/o操作(海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响3）问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度。
javascript数据结构之多叉树经典操作示例【创建、添加、遍历、移除等】
10-18
多叉树是数据结构中的一种重要结构，它能够有效地存储具有层级关系的数据，如组织结构、目录结构等。在JavaScript中，多叉树可以通过面向对象的方式构建，其中，节点（Node）是构成多叉树的基础，而树（Tree）则是由...
自己用C语言实现的拓扑多叉树
09-06
学习和理解这个项目，不仅可以加深对C语言内存管理和指针操作的理解，还可以掌握多叉树这种数据结构及其操作，这对于解决涉及层次关系或网络结构的问题非常有用。例如，在编译器设计、图形渲染、文件系统、网络路由...
树状数据（多叉树）在数据库中存储的示例源码
03-01
在IT领域，树状数据结构是一种非常重要的抽象概念，它广泛应用于各种场景，如文件系统、数据索引、网络路由等。多叉树是树结构的一种变体，每个节点可以有多个子节点，区别于二叉树（每个节点最多两个子节点）。在...
数据结构——多叉树、B树
共勉
05-26 721
二叉树存在的问题： 二叉树需要加载到内存的，当如果二叉树的节点很多的时候，就存在如下问题 问题1:在构建叉树时,需要多次进行 I/O 操作海量数据存在数据库或文件中)，节点海量，构建二叉树时，速度有影响 问题2:节点海量，也会造成二叉树的高度很大，会降低操作速度 解决这个问题就需要使用到多叉树： 在二叉树中，每个节点有数据项，最多有两个子节点。如果允许每个节点可以更多的数据项和更多的子节点，就是多叉树(multiwaytree) 多叉树通过重新组织节点，减少树的高度，能对二叉树进行优化。 2-3树的
多叉树的基本操作(C++实现)
热门推荐
锦恢的博客
11-12 1万+
文章目录前言创建多叉树展示多叉树销毁一颗多叉树前序遍历(递归&非递归)递归写法非递归写法后序遍历(递归&非递归)递归写法非递归写法层次遍历计算多叉树的高度计算多叉树叶子节点的个数打印输出根节点到所有叶子节点的路径(深度优先-递归)打印输出根节点到所有叶子节点的路径(基于后序遍历-非递归)打印输出根节点到所有叶子节点的路径(基于层次遍历-非递归)输出根节点到叶子节点所有路径中最长的那些路径递归实现节点的插入删除子树递归实现最近公共祖先查询 前言 我们都知道如何表达一颗二叉树：使用结构体记录每个
c语言多叉树二重指针的用法,Python Treelib 多叉树 数据结构 中文使用帮助文档
weixin_29781865的博客
05-20 196
Python Treelib 多叉树 数据结构 中文使用帮助文档树，对于计算机编程语言来说是一个重要的数据结构。它具有广泛的应用，比如文件系统的分层数据结构和机器学习中的一些算法。这里创建了treelib来提供Python中树数据结构的高效实现。1.安装主要通过pip和easy_install进行安装windows下：pip install treelibLinux下：sudo easy_inst...
【数据结构】多叉树的常见形式
doomwatcher的博客
04-02 2272
多叉树的多种形态，和不同的的应用部分
C语言 | 算法 | BFS
Yalena_的博客
05-15 1537
算法笔记
C语言多叉树求宽度,c语言 多叉树结构相关
weixin_26712075的博客
05-21 176
实现多叉树时，由于非叶子节点的子节点的个数不同，所以如何动态的创建节点是个问题数据结构:struct list{/* other data */int effectif_class_1;int effectif_class_2;struct list *parent;struct list *child[];}struct list * findNode(struct list *point){i...
一种多叉树的前序遍历C实现算法代码例子
marks_001的博客
01-16 574
一种多叉树的前序遍历C实现算法代码例子 在偶然的机会间涉及到了要对某些多未知数多方程求解其中的多数公因式的工程，然后在寻找他们的公因式时需要对其所有因式进行查找对比，由此自己感兴趣地花了几个时间写了一个小代码实现其寻找，其剖析开来就是多叉树的前序遍历算法，其中也没使用到指针，但是也是多叉树的数据结构。 我先介绍一下我当时面对的对象。如下方程式 a=b+c(d+e+t)-f(g+h(i+j)); 大概是形同这样的若干个的方程式子，其中每个字母可看作一个因式，或者他们结合成因式，然后主要是对他们进行遍历查找其每
二叉树、自平衡二叉树和多叉树详解
快乐的小三菊的博客
10-21 1858
二叉树、自平衡二叉树和多叉树简单介绍，以及排序方式
C++语言实现多叉树功能
qq_38733782的博客
03-06 6064
参考了这篇文章https://segmentfault.com/a/1190000002451356CTreeData 为插入节点数据，用户可以根据自身情况自定义tree.h#ifndef _TREE_H_ #define _TREE_H_ #include&lt;stdlib.h&gt; #include&lt;string.h&gt; class CNode { public: C...
广度优先搜索(BFS)的C语言实现
MZ21G的博客
03-01 3727
广度优先搜索算法（英语：Breadth-First Search，缩写为BFS），又译作宽度优先搜索，或横向优先搜索，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。 #include <bits/stdc++.h> using namespace std; static const int N = 10; stati...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值