C语言学习：图的优先遍历算法

最新推荐文章于 2024-03-21 22:16:18 发布
最新推荐文章于 2024-03-21 22:16:18 发布
阅读量137 收藏 2
点赞数
文章标签： 算法 c语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43013173/article/details/135088744
版权

分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历。

运算分析：

（1）深度优先遍历：

①从图中某个顶点V0出发，首先访问V0。

②找出刚访问过的顶点的第一个未被访问的邻接点,然后访问该顶点。以该顶点为新顶点，重复此步骤，直到刚访问过的顶点没有未被访问的邻接点为止。

③返回前一个访问过的且仍有未被访问的邻接点的顶点,找出该顶点的下一个未被访问的邻接点,访问该顶点；然后执行步骤②。

（2）广度优先遍历：

①从图中某个顶点v0出发，首先访问v0。

②依次访问v0的各个未被访问的邻接点。

③分别从这些邻接点(端结点)出发，依次访问它们的各个未被访同的邻接点(新的端结点)。访问时应保证：如果vi和vk为当前端结点，且vi在vk之前被访问，则vi的所有未被访问的邻接点应在vk的所有未被访问的邻接点之前访问。重复③，直到所有端结点均没有未被访问的邻接点为止。

测试数据分析：

一、邻接矩阵表示法

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

#define MAXVNUM 100 // 最大顶点数 
#define INFINITY 65535

int visited[MAXVNUM]={0}; // 记录顶点是否已被访问
typedef char VerData;

typedef struct {
    VerData vertex[MAXVNUM]; // 顶点数组
    int arc[MAXVNUM][MAXVNUM]; // 邻接矩阵
    int vertexnum; // 顶点数量
    int arcnum; // 边数量
}AdjMatrix;

typedef struct Node
{
    VerData data;
    struct Node* next;
}LinkQueueNode;

typedef struct
{
    LinkQueueNode* front;
    LinkQueueNode* rear;
}LinkQueue;

int InitQueue(LinkQueue* Q)
{
    Q->front = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    if (Q->front!= NULL)
    {
        Q->rear = Q->front;
        Q->front->next = NULL;
        return 1;
    }
    else return 0;
}

int EnterQueue(LinkQueue* Q, VerData x)
{
    LinkQueueNode* NewNode;
    NewNode = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    if (NewNode != NULL)
    {
        NewNode->data = x;
        NewNode->next = NULL;
        Q->rear->next = NewNode;
        Q->rear = NewNode;
        return 1;
    }
    else return 0;
}

int DeleteQueue(LinkQueue* Q, VerData* x)
{
    LinkQueueNode* p;
    if (Q->front->next == NULL)
        return 0;
    p = Q->front->next;
    Q->front->next = p->next;
    if (Q->rear == p)
        Q->rear = Q->front;
    *x = p->data;
    free(p);
    return 1;
}

int locateVex(AdjMatrix* G, VerData u)
{
    int j =-1, k;
    for (k = 0; k < G->vertexnum; k++)
        if (G->vertex[k] == u){
            j=k;
            break;
        }
    return (j);
}

int createGraph(AdjMatrix* G)
{
    int i,j,k,w;			//i,j代表顶点下标,w代表权值
    VerData v1,v2;			//v1,v2为顶点数据

    printf("请输入顶点个数和边的数量!\n");
    scanf("%d %d", &G->vertexnum,&G->arcnum);
    getchar();

    for (i = 0; i < G->vertexnum; i++){
        for (j = 0; j < G->vertexnum; j++){
            G->arc[i][j] = INFINITY;
        }
    }
    printf("请输入顶点!\n");
    for (i = 0; i < G->vertexnum; i++)
        scanf(" %c", &G->vertex[i]);//输入顶点数据
        getchar();

    printf("请输入顶点和权重!\n");
    for (k = 0; k < G->arcnum; k++)
    {
        scanf("%c %c %d",&v1,&v2,&w);
        getchar();
        i = locateVex(G,v1);
        j = locateVex(G,v2);
        G->arc[i][j] = w;
        G->arc[j][i] = w;
    }
    printf("\n");
    return 1; 
}

void showGraph(AdjMatrix *G)
{
    printf("邻接矩阵：\n");
    for (int i = 0; i < G->vertexnum; i++)
    {
        for (int j = 0; j < G->vertexnum; j++)
        {
            if (G->arc[i][j] == INFINITY)
                printf("0  ");
            else
                printf("%d  ", G->arc[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void DFS(AdjMatrix* G, int v) {
    visited[v] = 1;
    printf("%c ", G->vertex[v]);
    for (int i = 0; i < G->vertexnum; i++) {
        if (G->arc[v][i] != INFINITY && !visited[i]) {
            DFS(G, i);
        }
    }
}

void DFSTraverse(AdjMatrix* G) {
    for (int i = 0; i < G->vertexnum; i++) {
        visited[i] = 0;
    }
    for (int i = 0; i < G->vertexnum; i++) {
        if (!visited[i]) {
            DFS(G, i);
        }
    }
}

void BFSTraverse(AdjMatrix* G) {
    LinkQueue Q;
    InitQueue(&Q);
    for (int i = 0; i < G->vertexnum; i++) {
        visited[i] = 0;
    }
    for (int i = 0; i < G->vertexnum; i++) {
        if (!visited[i]) {
            visited[i] = 1;
            printf("%c ", G->vertex[i]);
            EnterQueue(&Q, G->vertex[i]);
            while (Q.front != Q.rear) 
{
                VerData u;
                DeleteQueue(&Q, &u);
                int k = locateVex(G, u);
                for (int j = 0; j < G->vertexnum; j++) {
                    if (G->arc[k][j] != INFINITY && !visited[j]) {
                        visited[j] = 1;
                        printf("%c ", G->vertex[j]);
                        EnterQueue(&Q, G->vertex[j]);
                    }
                }
            }
        }
    }
}

int main() {
    AdjMatrix G; 
    createGraph(&G);
    showGraph(&G);

    printf("深度优先遍历结果：");
    DFSTraverse(&G);
    printf("\n");
    printf("广度优先遍历结果：");
    BFSTraverse(&G);
    printf("\n");
    return 0;
}

测试结果：

二、邻接表表示法

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

#define MAXVNUM 100

typedef char VerData;
typedef struct ArcNode {
    int adjvex;
    struct ArcNode* nextarc;
} ArcNode;

typedef struct VertexNode {
    VerData data;
    ArcNode* firstarc;
} VertexNode;

typedef struct {
    VertexNode vertex[MAXVNUM];
    int vertexnum;
    int arcnum;
} AdjList;

typedef struct Node {
    VerData data;
    struct Node* next;
} LinkQueueNode;

typedef struct {
    LinkQueueNode* front;
    LinkQueueNode* rear;
} LinkQueue;

int visited[MAXVNUM];

void DFS(AdjList* G, int v) {
    
    printf("%c ", G->vertex[v].data);
    visited[v] = 1;
    ArcNode* p = G->vertex[v].firstarc;
    while (p != NULL) {
        
        if (!visited[p->adjvex]) {
            DFS(G,p->adjvex);
        }
        p = p->nextarc;
    }
}

void DFSTraverse(AdjList* G) {
    int i;
    for (i = 0; i < G->vertexnum; i++)
        visited[i] = 0;
    for (i = 0; i < G->vertexnum; i++)
        if (!visited[i]) 
            DFS(G, i);
}

int InitQueue(LinkQueue* Q) {
    Q->front = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    if (Q->front != NULL) {
        Q->rear = Q->front;
        Q->front->next = NULL;
        return 1;
    }
    else return 0;
}

int EnterQueue(LinkQueue* Q, VerData x) {
    LinkQueueNode* NewNode;
    NewNode = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    if (NewNode != NULL) {
        NewNode->data = x;
        NewNode->next = NULL;
        Q->rear->next = NewNode;
        Q->rear = NewNode;
        return 1;
    }
    else return 0;
}

int DeleteQueue(LinkQueue* Q, VerData* x) {
    LinkQueueNode* p;
    if (Q->front == Q->rear)
        return 0;
    p = Q->front->next;
    Q->front->next = p->next;
    if (Q->rear == p)
        Q->rear = Q->front;
    *x = p->data;
    free(p);
    return 1;
}

void BFSTraverse(AdjList* G) {
    LinkQueue Q;
    InitQueue(&Q);
    for (int i = 0; i < G->vertexnum; i++) {
        visited[i] = 0;
    }
    for (int i = 0; i < G->vertexnum; i++) {
        if (!visited[i]) {
            visited[i] = 1;
            printf("%c ", G->vertex[i].data);
            EnterQueue(&Q, G->vertex[i].data);
            while (Q.front != Q.rear) {
                VerData u;
                DeleteQueue(&Q, &u);
                int k = locateVex(G, u);
                ArcNode* p = G->vertex[k].firstarc;
                while (p != NULL) {
                    if (!visited[p->adjvex]) {
                        visited[p->adjvex] = 1;
                        printf("%c ", G->vertex[p->adjvex].data);
                        EnterQueue(&Q, G->vertex[p->adjvex].data);
                    }
                    p = p->nextarc;
                }
            }
        }
    }
}

int locateVex(AdjList* G, VerData u) {
    int i;
    for (i = 0; i < G->vertexnum; i++)
        if (G->vertex[i].data == u) 
            return i;
    return -1;
}

int createGraph(AdjList* G) {
    int i, j, k;
    VerData v1=0, v2=0,e;
    printf("请输入顶点个数和边的数量!\n");
    scanf_s("%d %d", &G->vertexnum, &G->arcnum);
    e=getchar();

    printf("请输入顶点!\n");
    for (i = 0; i < G->vertexnum; i++) {
        scanf_s(" %c", &G->vertex[i].data,1);
        G->vertex[i].firstarc = NULL;
    }
    e=getchar();

    printf("请输入各边的顶点!\n");
    for (k = 0; k < G->arcnum; k++) {
        scanf_s("%c %c",&v1,1,&v2,1);
        e=getchar();
        i = locateVex(G, v1);
        j = locateVex(G, v2);

        ArcNode* p1;
        p1= (ArcNode*)malloc(sizeof(ArcNode));
        if (p1 == NULL) return;
        p1->adjvex = j;
        p1->nextarc = G->vertex[i].firstarc;
        G->vertex[i].firstarc = p1;

        ArcNode* p2;
        p2 = (ArcNode*)malloc(sizeof(ArcNode));
        if (p2 == NULL) return;
        p2->adjvex = i;
        p2->nextarc = G->vertex[j].firstarc;
        G->vertex[j].firstarc = p2;
    }
    return 1;
}

void ShowList(AdjList G) {
    ArcNode* p;
    p = (ArcNode*)malloc(sizeof(ArcNode));
    
    printf("邻接表：\n");
    for (int i = 0; i < G.vertexnum; i++)
    {
        printf(" %c", G.vertex[i].data);
        for (p = G.vertex[i].firstarc; p != NULL; p = p->nextarc)
            printf("->%d", p->adjvex);
        printf("\n");
    }
}
int main() {

    AdjList G;
    createGraph(&G);
    ShowList(G);
    printf("\n深度优先遍历结果：");
    DFSTraverse(&G);
    printf("\n广度优先遍历结果：");
    BFSTraverse(&G);
    printf("\n");
    return 0;
}

测试结果：

晞微
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
图的深度优先遍历（c语言）
12-29
图的深度优先遍历c语言版 受益良多 可参考数据结构|（清华版 主编 严蔚敏）
图的深度优先遍历（C语言数据结构）
08-25
图的深度优先遍历（C语言数据结构）C语言的代码，可用visual C++进行编译
图的深度优先遍历-C语言实现
热门推荐
鲍礼彬的CSDN博客 ~_~
10-16 3万+
#include #include #include #include #define MAXLIN 40 /*----邻接表存储结构---*/ //-----------------表节点存储结构---------- typedef struct ArcNode{                                            //结构体     int a
【C语言】图的广度优先遍历算法
csdnabcaq的博客
03-21 508
图的广度优先遍历算法类似与树的层序遍历，都需要借助队列来完成，但不同的是因为图中的数据元素之间的关系是多对多的，所以需要设置访问数组来表示每个数据元素是否被访问过，防止二次访问。即不断遍历访问当前节点及其所有未被访问的邻接点，直至无未被访问结点，再从这些邻接点开始出发遍历。
C语言 图的深度优先遍历
m0_46943867的博客
06-02 2817
实验内容 （1）实现图的邻接矩阵表示，并创建图； （2）对邻接矩阵表示的图实现深度优先遍历； 深度优先遍历的基本思想： ① 选择一个起始点出发，并访问之； ②一次从起始点的未访问过的邻接点出发，深度遍历图，直到图中与起始点有 路径相通的顶点都被访问过为止； ③如此时图中尚有顶点未被访问过，则另选图中一个未访问过的顶点作起始点， 重复上述过程，直到所有顶点被访问过为止。 ...
图的深度优先遍历DFS（C语言）
派拉斯兔子的博客
08-04 1879
一、图的深度优先遍历DFS （一）图的深度优先遍历 bool visited[MAX_VERTEX_NUM]; //访问标记数组,????初始值为false void DFS(Graph G, int v){ //从顶点v出发,深度优先遍历图G visit(v); //访问顶点v visited[v]=TRUE; //设已访问标记 for(w=FirstNeighbor(G,v); w>=0; w=NextNeighor(G,v,w)){ if(!visited[w]){ //w为u的尚未访
数据结构学习。C语言实现算法：图的深度优先遍历与广度优先遍历、 二叉查找树、 二叉树 、堆排序算法、 KMP算法、 链表.zip
最新发布
06-14
新手学习C语言的绝佳资料
《妙趣横生的算法(C语言实现)》（杨峰 编著）
01-22
《妙趣横生的算法(C语言实现)》可作为算法入门人员的教程，也可以作为学习过C语言程序设计的人士继续深造的理想读物，也可作为具有一定经验的程序设计人员巩固和提高编程水平，查阅相关算法实现和数据结构知识的参考...
严蔚敏：数据结构题集(C语言版)
09-02
《数据结构》(C语言版)是为“数据结构”课程编写的教材,也可作为学习数据结构及其算法的C程序设计的参考教材。本书的前半部分从抽象数据类型的角度讨论各种基本类型的数据结构及其应用;后半部分主要讨论查找和排序的...
通俗易懂的啊哈C语言1
03-29
第2节 城市地图——图的深度优先遍历 136 第3节 zui少转机——图的广度优先遍历 142 第6章 zui短路径 147 第1节 只有五行的算法——Floyd-Warshall 148 第2节 Dijkstra算法——通过边实现松弛 155 第3节 ...
C语言数据结构基础 图的深度优先遍历
hhhwx666的博客
12-23 462
图作为一种复杂的数据结构，也存在遍历问题。图的遍历就是从图中的某个顶点出发，按某种方法对图中的所有顶点访问且仅访问一次，图的遍历算法是求解图的连通性问题，拓扑排序和关键路径等算法的基础。图的遍历比起树的遍历要复杂得多。由于图中顶点关系是任意的，即图中顶点之间是多对多的关系，图可能是非连通图，图中还可能存在回路，因此在访问了某个顶点后，可能沿着某条路径搜素后又回到该顶点上。
图的深度、广度优先遍历（c语言）
12-20
本程序方便的实现了图的深度、广度优先遍历。是数据结构中的一部分，现与大家分享
图的深度优先遍历与广度优先遍历(C语言实现)
10-17
数据结构中的图结构，其中最重要的两个遍历算法——深度优先遍历与广度优先遍历
深度优先算法，图的遍历（c语言）
06-22
深度优先算法，图的遍历（c语言）
c语言 无向图的深度优先遍历算法实现
11-30
通过键盘输入图的顶点，以及每一条边的两个顶点，从而建立无向图。实现无向图的深度优先遍历算法。要求以用户给定的结点为起始点，显示深度优先遍历次序。
图的深度优先遍历算法源码
05-17
图的深度优先遍历算法 经过调试 可以运行。。。
超详细C语言版数据结构：图的深度优先遍历（推荐收藏）
「 刘一哥与GIS的故事」
06-25 1万+
文章目录一、邻接矩阵存储图的深度优先遍历过程分析二、结果分析三、C语言编程实现图的深度优先遍历四、图的遍历及其应用 一、邻接矩阵存储图的深度优先遍历过程分析 对图1这样的无向图，要写成邻接矩阵，则就是下面的式子： 一般要计算这样的问题，画成表格来处理是相当方便的事情，实际中计算机处理问题，也根本不知道所谓矩阵是什么，所以画成表格很容易帮助我们完成后面的编程任务。在我们前面介绍的内容中，有不少是借助着表格完成计算任务的，如Huffman树。 为了记录那些顶点是已经走过的，还要设计一个表来标记已经走过的顶
C语言入门——DFS图的深度优先遍历
jsnsbhzukkzns的博客
01-22 1055
注意，注意，这里是C语言入门
C语言经典算法之图的深度优先遍历
weixin_56154577的博客
01-24 1433
深度优先遍历（DFS）是处理图节点的算法，选择起始节点，标记为已访问并加入遍历路径。通过递归访问邻接节点，深入直到无法继续，然后回溯至上一个节点，重复步骤直到遍历完整个图。
c语言中学过的10-15个算法
12-07
在C语言中，我们学习了许多算法，以下是其中的10-15个算法： 1. 线性搜索算法：顺序地在列表中搜索目标值。 2. 二分查找算法：针对有序列表，使用折半方法搜索目标值。 3. 冒泡排序算法：通过多次比较和交换相邻元素来进行排序。 4. 插入排序算法：逐个将未排序的元素插入已排序的部分中。 5. 选择排序算法：每次从未排序的部分中选择最小元素并放到已排序的部分中。 6. 归并排序算法：将列表递归地分成两半，然后按照大小合并两个已排序的部分。 7. 快速排序算法：选择一个基准元素，将列表分割为两部分，使得比基准元素小的在其左侧，大的在右侧，然后递归地对两个部分排序。 8. 计数排序算法：通过确定每个元素前面有多少个较小元素来进行排序。 9. 桶排序算法：将元素分配到不同的桶中，然后在每个桶中分别排序。 10. 堆排序算法：使用堆数据结构进行排序，将元素加入堆，然后依次取出最小（或最大）元素。 11. 图的深度优先遍历算法：使用栈或递归方式实现的遍历算法。 12. 图的广度优先遍历算法：使用队列实现的遍历算法。 13. 最短路径算法：例如Dijkstra算法和Floyd-Warshall算法，用于找到两个节点之间的最短路径。 14. 最小生成树算法：例如Prim算法和Kruskal算法，用于找到一个图的最小生成树。 15. 搜索算法：例如深度优先搜索和广度优先搜索，用于解决问题，如迷宫问题和八皇后问题。 以上是C语言中学习的一些常见算法，它们在编程中有着广泛的应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

晞微

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

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

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

打赏作者

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

抵扣说明：

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

余额充值