有向图的DFS，BFS

题目描述

从键盘接收有向图的顶点集，弧集，创建有向图，并完成下列任务：

（1）计算结点的出度、入度以及度;

(2) 从第一个顶点出发，求一个深度优先遍历序列;

(3) 从第一个顶点顶点出发，求一个广度优先遍历序列。

注意：以用户输入各个顶点的顺序为顶点的序号。

在深度和广度优先遍历中，优先选择序号小的顶点。

输入

第一行输入两个整数，以空格隔开，分别代表图的顶点数n和弧数e。(顶点个数<=20) 第二行依次输入顶点值，类型为字符，中间不用间隔符。 接下去有e行，每行为两个字符 uv（中间没有间隔符），表示一条弧

输出

连续输出n行，依次为各个结点的出度和入度，格式为【顶点w 出度值 入度值 度值】，四者间用空格隔开。 接下去的一行，输出深度优先遍历顶点序列（顶点间无间隔符）。

最后一行，输出广度优先遍历顶点序列（顶点间无间隔符）。

样例输入

5 7
ABCDE
AB
AE
BC
CD
DA
DB
EC

样例输出

A 2 1 3
B 1 2 3
C 1 2 3
D 2 1 3
E 1 1 2
ABCDE
ABECD

代码

---

#ifndef QUEUE
#define QUEUE

#define maxsize 50

typedef struct {
	int data[maxsize];
	int front;
	int rear;
}*Queue, Node;

#endif


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

int qqq[2000];

void initQueue(Queue queue)
{
	queue->front = 0;
	queue->rear = 0;
}

bool isEmpty(Queue queue)
{
	if (queue->front == queue->rear) {
		return true;
	}
	return false;
}

bool isFull(Queue queue)
{
	if ((queue->rear + 1) % maxsize == queue->front) {
		return true;
	}
	return false;
}

bool Enqueue(Queue queue, int num)
{
	if (isFull(queue)) {
		return false;
	}
	queue->data[queue->rear] = num;
	queue->rear = (queue->rear + 1) % maxsize;
	return true;
}

bool Dequeue(Queue queue, int *x)
{
	if (isEmpty(queue)) {
		return false;
	}
	*x = queue->data[queue->front];
	queue->front = (queue->front + 1) % maxsize;
	return true;
}



#define MAXVEX 100

bool visited[100];

typedef struct {
	char vexs[MAXVEX];
	int arc[MAXVEX][MAXVEX];
	int numVert, numEdge;
	int out[MAXVEX];
	int in[MAXVEX];
}Graph;

void createGraph(Graph * G)
{
	int i, j, k, w;
	int ii, jj;
	char a, b;
	scanf("%d%d", &G->numVert, &G->numEdge);
	getchar();
	for (i = 0; i < G->numVert; i++) {
		scanf("%c", &G->vexs[i]);
	}
	getchar();
	for (i = 0; i < G->numVert; i++) {
		for (j = 0; j < G->numVert; j++) {
			G->arc[i][j] = 0;
		}
		G->in[i] = G->out[i] = 0;
	}


	for (k = 0; k < G->numEdge; k++) {
		
		scanf("%c%c", &a, &b);
		getchar();
		for (i = 0; i < G->numVert; i++) {
			if (G->vexs[i] == a) {
				ii = i;
				G->in[ii]++;
				break;
			}
		}
		for (i = 0; i < G->numVert; i++) {
			if (G->vexs[i] == b) {
				jj = i;
				G->out[jj]++;
				break;
			}
		}
		G->arc[ii][jj] = 1;
	}
}

void BFSTraverse(Graph G)
{
	int i, j;
	Queue q = (Queue)malloc(sizeof(Node));
	initQueue(q);
	for (i = 0; i < G.numVert; i++) {
		visited[i] = false;
	}
	for (i = 0; i < G.numVert; i++) {
		if (!visited[i]) {
			visited[i] = true;
			printf("%c", G.vexs[i]);
			Enqueue(q, i);
			while (!isEmpty(q)) {
				Dequeue(q, &i);
				for (j = 0; j < G.numVert; j++) {
					if (G.arc[i][j] == 1 && !visited[j]) {
						visited[j] = true;
						printf("%c", G.vexs[j]);
						Enqueue(q, j);
					}
				}
			}
		}
	}
	
}

void DFS(Graph G, int i)
{
	int j;
	visited[i] = true;
	printf("%c", G.vexs[i]);
	for (j = 0; j < G.numVert; j++) {
		if (G.arc[i][j] == 1 && !visited[j]) {
			DFS(G, j);
		}
		qqq[j] = 1;
	}
}

void DFSTraverse(Graph G)
{
	int i;
	for (i = 0; i < G.numVert; i++) {
		visited[i] = false;
	}
	for (i = 0; i < G.numVert; i++) {
		if (!visited[i]) {
			DFS(G, i);
		}
	}
}

int main(void)
{
	Graph G;
	createGraph(&G);

	for (int i = 0; i < G.numVert; i++) {
		printf("%c ", G.vexs[i]);
		printf("%d %d %d\n", G.in[i], G.out[i], G.in[i] + G.out[i]);
	}
	DFSTraverse(G);
	putchar('\n');
	BFSTraverse(G);
	putchar('\n');
}