day5--图的创建与DFS和BFS遍历

DFS使用数据结构栈（stack）或递归实现，其空间复杂度为O(n)

BFS利用数据结构队列（queue）实现，空间复杂度为O(2^n)，另外BFS可以用来解决最短路问题

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

//图结构体的定义 
typedef struct Graph {
	char* vexs;	//结点
	int** arcs;	//边 
	int vexNum;	//结点个数 
	int arcNum;	//边的条数 
}Graph;

//初始化图 
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* vex, int* arc) {
	for(int i = 0; i < G -> vexNum; i++) {
		G -> vexs[i] = vex[i];
		for(int j = 0; j < G ->vexNum; j++) {
			G -> arcs[i][j] = *(arc + i * G ->vexNum + j);
			if(G -> arcs[i][j] != 0)
				G -> arcNum++;
		}
	}
	G -> arcNum /= 2;	//边数除以二，因为上面累加了两次 
}

//深度优先遍历 
void DFS(Graph* G, int* visited, int index) {
	printf("%c ",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);
		}
	}
}

#define MAX 10

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

Queue* initQueue() {
	Queue* Q = (Queue*)malloc(sizeof(Queue));
	Q -> front = 0;
	Q -> rear = 0;
	return Q;
}

int isEmpty(Queue* Q) {
	if(Q -> front == Q -> rear)
		return 1;
	else
		return 0;
}

int isFull(Queue* Q) {
	if(Q -> rear + 1 % MAX == Q -> front)
		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 ) % MAX;
		return 1;
	}
}

int deQueue(Queue* Q) {
	if(isEmpty(Q)) {
		return -1;
	}
	else {
		int data = Q -> data[Q -> front];
		Q -> front = (Q ->front + 1) % MAX;
		return data; 
	}
}

//广度优先遍历--类似于树的层次遍历--用到队列 
void BFS(Graph* G, int* visited, int index) {
	Queue* Q = initQueue();
	printf("%c ",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 ", G -> vexs[j]);
				visited[j] = 1;
				enQueue(Q, j);
			}
		}
	}
}

int main() {
	Graph* G = initGraph(5);
	int arc[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", *arc);
	int* visited = (int*)malloc(sizeof(int) * G -> vexNum);
	for(int i = 0; i < G -> vexNum; i++)
		visited[i] = 0;
	DFS(G, visited, 0);
	puts("");
	
	for(int i = 0; i < G -> vexNum; i++)
		visited[i] = 0;
	BFS(G, visited, 0);
	puts("");
	return 0;
}