图的创建和BTS,DTS算法 C

想要成为社畜的大学生

已于 2024-02-28 12:55:31 修改

阅读量128

点赞数 1

文章标签：算法数据结构图论

于 2024-01-30 22:29:14 首次发布

本文链接：https://blog.csdn.net/zxxcccc11/article/details/135942743

版权

本文介绍了如何在C语言中使用邻接矩阵表示图，并展示了如何使用广度优先搜索(BFS)和深度优先搜索(DFS)算法遍历图。作者通过实例展示了初始化图、创建邻接矩阵以及执行BFS和DFS的过程。

摘要由CSDN通过智能技术生成

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 5
typedef struct Graph {
    char* vexs;
    int** arcs;
    int vexsNum;
    int arcNum;
}Graph;
typedef struct Queue {
    int front;
    int rear;
    int data[MAXSIZE];
}Queue;
Queue*initQueue(){
    Queue* Q = (Queue*)malloc(sizeof(Queue));
    Q->rear = Q->front = 0;
    return Q;
}
int isFull(Queue*Q) {
    if ((Q->rear+1)%MAXSIZE==Q->front)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
int isEmpty(Queue* Q) {
    if (Q->front==Q->rear)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
int enQueue(Queue* Q, int data) {
    if (isFull(Q))
    {
        return 0;
    }
    else
    {
        Q->data[Q->rear] = data;
        Q->rear = (Q->rear + 1) % MAXSIZE;
        return 1;
    }
}
int deQueue(Queue* Q) {
    if (isEmpty(Q))
    {
        return -1;
    }
    else
    {
        int data = Q->data[Q->front];
        Q->front = (Q->front+1) % MAXSIZE;
        return data;
    }
}
Graph* initGraph(int length) {
    Graph* G = (Graph*)malloc(sizeof(Graph));
    G->vexs = (char*)malloc(sizeof(char) * length);
    G->arcs = (int**)malloc(sizeof(int*) * length);
    for (int i = 0; i < length; i++)
    {
        G->arcs[i] = (int*)malloc(sizeof(int)*length);
    }
    G->vexsNum = length;
    G->arcNum = 0;
    return G;
}
void createGraph(Graph*G,char*vexs,int*arcs) {
    for (int i = 0; i < G->vexsNum; i++)
    {
        G->vexs[i] = vexs[i];
        for (int j = 0; j < G->vexsNum; j++)
        {
            G->arcs[i][j] = *(arcs + i * G->vexsNum + j);
            /*
            这行代码的目的是将二维数组 `arcs` 中的元素复制到图的邻接矩阵中。让我解释一下：

            `arcs` 是一个一维数组，但我们把它当作一个二维数组来处理。
            在内存中，它是一片连续的整数存储区域。

            这个二维数组中，第 `i` 行、第 `j` 列的元素
            通过 `*(arcs + i * G->vexNum + j)访问。
            这是因为我们将一维数组 `arcs` 当作一个二维数组来使用，
            其中 `i * G->vexNum + j` 是 
            通过行数和列数计算得到的索引。

            `G->arcs[i][j]` 表示图的邻接矩阵中第 `i` 个顶点到第 `j` 个顶点的边的权值。
             这个值被赋为 `*(arcs + i * G->vexNum + j)`，
             即二维数组 `arcs` 中对应位置的值。

            这一行代码的效果是将 `arcs` 中的元素复制到图的邻接矩阵中，
            以便后续能够通过邻接矩阵表 示图的结构。
            
            */
            if (G->arcs[i][j]!=0)
            {
                G->arcNum++;
            }
        }
    }
    G->arcNum /= 2;
}
void BFS(Graph*G,int*visited,int index) {
    Queue* Q = initQueue();
    printf("%c\t", G->vexs[index]);
    visited[index] = 1;
    enQueue(Q, index);
    while (!isEmpty(Q))
    {
        int i=deQueue(Q);
        for (int j = 0; j < G->vexsNum; j++)
        {
            if (G->arcs[i][j]==1&&!visited[j])
            {
                printf("%c\t", G->vexs[j]);
                    visited[j] = 1;
                    enQueue(Q, j);
            }
        }
        
    }
   

}
void DFS(Graph*G,int*visited,int index) {
    printf("%c\t", G->vexs[index]);
    visited[index] = 1;
    for (int i = 0; i < G->vexsNum; i++)
    {
        if (G->arcs[index][i]==1&&!visited[i])
        {
            DFS(G, visited, i);
        }
    }
    
}
int main() {
    Graph* G = initGraph(5);
    int* visited = (int*)malloc(sizeof(int) * G->vexsNum);
    for (int i = 0; i < G->vexsNum; i++)
        visited[i] = 0;
    int arcs[5][5] = {
        0,1,1,1,0,
        1,0,1,1,1,
        1,1,0,0,0,
        1,1,0,0,1,
        0,1,0,1,0
    };
    createGraph(G, "ABCDE", (int*)arcs);
    DFS(G, visited, 0);
    printf("\n");
    for (int i = 0; i < G->vexsNum; i++)
    {
        visited[i] = 0;
    }
    BFS(G,visited,0);
    printf("\n");
    return 0;
}

参考：

分类: Data Structure | tyrantlucifer