BFS DFS

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include<stdio.h>
#define MAXSIZE 5 
//图的邻接矩阵(Adjacency Matrix) 存储方式是用两个数组来表示图。
// 一个一维数组存储图中顶点信息，一个二维数组(称为邻接矩阵)存储图中的边或弧的信息。
//typedef struct Graph {
//    char* vexs;//顶点表 vertex
//    int** arcs;//二级指针  相当于二维数组-->邻接矩阵
//    int vexNum;//图当顶点数
//    int arcNum;//图当前边数
//}Graph;

typedef struct Graph {
    char* vexs;
    int** arcs;
    int vexNum;
    int arcNum;
}Graph;

typedef struct Queue {
    int front;
    int rear;
    int data[MAXSIZE];
}Queue;

Queue* initQueue() {
    Queue* Q = (Queue*)malloc(sizeof(Queue));
    Q->front = Q->rear = 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 vexNum) {
    Graph* G = (Graph*)malloc(sizeof(Graph));
    G->vexs = (char*)malloc(sizeof(char)*vexNum);
    G->arcs = (int**)malloc(sizeof(int*) * vexNum);//分配行指针的 这是二级指针 指向一级指针
    for (int i = 0;  i<vexNum;i ++)
    {
        G->arcs[i] = (int*)malloc(sizeof(int) * vexNum);//分配一级指针的 这里的指针指向邻接矩阵 每一行的元素
    }
    G->vexNum = vexNum;
    G->arcNum = 0;//最开始没有边
    return G;
}
//初始化函数    传入 图 顶点 边
void createGraph(Graph* G, char* vexs, int* arcs){
    for (int i = 0; i < G->vexNum; i++) {
        G->vexs[i] = vexs[i];//传入顶点表到结构体中
        for (int j = 0; j < G->vexNum; j++) {
            G->arcs[i][j] = *(arcs + i * G->vexNum + j);
            //这里相当于把二维数组arcs一维化, i * G->vexNum 相当于跳过前面i行  j时第i+1行的偏移量
            if (G->arcs[i][j] != 0)
                G->arcNum++;
        }
    }
    G->arcNum /= 2;//无向图 算以此
}

//图的遍历
//BFS 
// 和二叉树的层次遍历相似
// 
// 
// 
//DFS深度优先遍历 
//一条路走到黑,不到南墙不回头 撞墙之火再回头 回头之后再撞墙
//1.找一个节点访问
//2.找这个节点可以访问的节点
//3.重复第一步,直到所有节点访问完毕
void DFS(Graph* G,int* visited ,int index)//传入一个图 一个数组标识是否访问 传入一个索引
{
    printf("%c\t",G->vexs[index]);
    visited[index] = 1;//访问完标记一下
    for (int i = 0; i < G->vexNum; i++)
    {
        if (G->arcs[index][i] == 1 && !visited[i]) {
            DFS(G, visited, i);
        }
    }
}

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 -> vexNum; j++) {
            if (G -> arcs[i][j] == 1 && !visited[j]) {
                printf("%c\t", G -> vexs[j]);
                visited[j] = 1;
                enQueue(Q, j);
            }
        }
    }
}
int main()
{
    Graph* G = initGraph(5);
    int* visited = (int*)malloc(sizeof(int) * G->vexNum);
    for (int i = 0; i < G->vexNum; 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->vexNum; i++)
        visited[i] = 0;
    BFS(G, visited, 0);
    printf("\n");
    return 0;
}