c++语言图

#include <iostream>
#include <stdio.h>
#include<Windows.h>
#include<stack>
#include<queue>
using namespace std;
#define NumVertices 10
int visited[NumVertices];  //访问标记数组是全局变量
typedef struct matrix {
	int vertex[NumVertices];
	int edge[NumVertices][NumVertices];
	int n, e; //图的顶点数与边数
}MTGraph;

//邻接表存储定义
typedef struct node {//边表结点
	int adjvex;            //邻接点域（下标）
	struct node *next; //下一边链接指针
} EdgeNode;
typedef struct {              //顶点表结点
	int vertex; //顶点数据域
	EdgeNode * firstedge;//边链表头指针
} VertexNode;
typedef struct {         //图的邻接表
	VertexNode vexlist[NumVertices];
	int n, e;            //顶点个数与边数
} AdjGraph;

typedef struct Address_Flag A_F;
//邻接矩阵实现
void CreateMGraph(MTGraph *G, FILE *fp) {
	int i, j, k, w;
	fscanf(fp, "%d", &G->n);//
	fscanf(fp, "%d", &G->e);//
	for (int t = 0; t < G->n; t++)
		G->vertex[t] = t;
	for (i = 0; i < G->n; i++)
		for (j = 0; j < G->n; j++)
			G->edge[i][j] = 0;
	for (k = 0; k < G->e; k++) {
		fscanf(fp, "%d,%d", &i, &j);//
		G->edge[i][j] = 1;
		//printf("%d", G->edge[i][j]);
		G->edge[j][i] = 1;
		//printf("%d", G->edge[j][i]);
	}
}
//邻接表实现
void CreateGraph(AdjGraph *G, FILE *fp1) {
	int tail, head;
	fscanf(fp1, "%d", &G->n);
	fscanf(fp1, "%d", &G->e);
	//printf("%d", G->e);
	for (int i = 0; i <G->n; i++) {
		G->vexlist[i].vertex = i;
		G->vexlist[i].firstedge = NULL;
	}
	for (int i = 0; i < G->e; i++) {
		fscanf(fp1, "%d,%d", &head, &tail);
		EdgeNode *p = (EdgeNode *)malloc(sizeof(EdgeNode));
		p->adjvex = head;
		p->next = G->vexlist[tail].firstedge;
		G->vexlist[tail].firstedge = p;
		p = (EdgeNode *)malloc(sizeof(EdgeNode));
		p->adjvex = tail;
		p->next = G->vexlist[head].firstedge;
		G->vexlist[head].firstedge = p;
	}
}
//邻接矩阵转邻接表
void MT_to_ADJ(MTGraph *G, AdjGraph *G1) {
	int n1;
	G1 = (AdjGraph *)malloc(sizeof(AdjGraph));
	G1->n = G->n;
	G1->e = G->e;
	n1 = G1->n;
	for (int i = 0; i < n1; i++) {
		G1->vexlist[i].vertex = i;
		G1->vexlist[i].firstedge = NULL;
	}
	for (int i = 0; i < n1; i++) {
		for (int j = n1 - 1; j >= 0; j--) {
			if (G->edge[i][j] != 0) {
				EdgeNode *p = (EdgeNode *)malloc(sizeof(EdgeNode));
				p->adjvex = j;
				p->next = G1->vexlist[i].firstedge;
				G1->vexlist[i].firstedge = p;
			}
		}
	}
}
//邻接表转邻接矩阵
void ADJ_to_MT(MTGraph *G, AdjGraph *G1) {
	int n1;
	EdgeNode *p;
	G->n = G1->n;
	G->e = G1->e;
	n1 = G->n;
	for (int i = 0; i < n1; i++) {
		for (int j = 0; j < n1; j++) {
			G->edge[i][j] = 0;
		}
	}

	for (int i = 0; i < n1; i++) {
		p = G1->vexlist[i].firstedge;
		while (p != NULL) {
			G->edge[i][p->adjvex] = 1;
			p = p->next;
		}
	}
}
//邻接矩阵深度优先搜索
void DFS1(MTGraph *G, int i) {
	printf("%d ", G->vertex[i]);
	visited[i] = 1;
	for (int j = 0; j < G->n; j++) {
		if ((G->edge[i][j] == 1) && (visited[j] == 0))
			DFS1(G, j);
	}
}
void DFSTraverse1(MTGraph *G) {
	for (int i = 0; i < G->n; i++)
	{
		visited[i] = 0;
	}
	for (int i = 0; i < G->n; i++)
		if (visited[i] == 0)
			DFS1(G, i);
}

//邻接表深度优先搜索
void DFS2(AdjGraph *G, int i) {
	EdgeNode *p;
	printf("%d ", G->vexlist[i].vertex);
	visited[i] = 1;
	p = G->vexlist[i].firstedge;
	while (p) {
		if (!visited[p->adjvex])
			DFS2(G, p->adjvex);
		p = p->next;
	}
}
void DFSTraverse2(AdjGraph *G) {
	for (int i = 0; i < G->n; i++)
		visited[i] = 0;
	for (int i = 0; i < G->n; i++)
		if (!visited[i])
			DFS2(G, i);
}

//邻接矩阵的深度优先搜索（非递归）

void DFS11(MTGraph *G)
{
	int i;
	int t;
	stack<int> S;

	for (i = 0; i<G->n; i++)
		visited[i] = 0;
	S.push(0);
	printf("%d ", 0);
	visited[0] = 1;
	while (!S.empty()) {
		t = S.top();
		//int q = 1;
		for (i = 0; i < G->n; i++) {
			if ((G->edge[t][i] == 1) && (!visited[i])) {
				S.push(i);
				printf("%d ", i);
				visited[i] = 1;
				//q = 0;
				break;
			}
		}
		if (i == G->n)S.pop();
	}
}


//邻接表的深度优先搜索（非递归）
void DFS22(AdjGraph *G) {
	int k;
	stack<int> S;
	for (int i = 0; i < G->n; i++)
		visited[i] = 0;
	S.push(0);
	printf("%d ", 0);
	visited[0] = 1;
	while (!S.empty()) {
		k = S.top();
		EdgeNode *p;
		p = G->vexlist[k].firstedge;
		while (p != NULL) {
			if ((p != NULL) && (!visited[p->adjvex])) {
				S.push(p->adjvex);
				printf("%d ", p->adjvex);
				visited[p->adjvex] = 1;
				break;
			}
			p = p->next;
		}
		if (p == NULL)S.pop();
	}
}

queue<size_t> Q;
void BFS1(MTGraph *G, int k) {
	int i, j;
	printf("%d ", G->vertex[k]);
	visited[k] = 1;
	Q.push(k);
	while (!Q.empty()) {
		i = Q.front();
		Q.pop();
		for (j = 0; j < G->n; j++) {
			if ((G->edge[i][j] == 1) && (!visited[j])) {
				printf("%d ", G->vertex[j]);
				visited[j] = 1;
				Q.push(j);
			}
		}
	}
}
//广度优先搜索主算法
void BFSTraverse1(MTGraph *G) {
	for (int i = 0; i < G->n; i++)
		visited[i] = 0;
	for (int i = 0; i < G->n; i++)
		if (!visited[i])
			BFS1(G, i);
}

//邻接表的广度优先搜索
void BFS2(AdjGraph *G, int k) {
	int i;
	EdgeNode *p;
	//queue<int> Q;
	printf("%d ", G->vexlist[k].vertex);
	visited[k] = 1;
	Q.push(k);
	while (!Q.empty()) {
		Q.pop();
		p = G->vexlist[k].firstedge;
		while (p) {
			if (!visited[p->adjvex]) {
				printf("%d ", G->vexlist[p->adjvex].vertex);
				visited[p->adjvex] = 1;
				Q.push(p->adjvex);
			}
			p = p->next;
		}
	}
}
void BFSTraverse2(AdjGraph *G) {
	for (int i = 0; i < G->n; i++)
		visited[i] = 0;
	for (int i = 0; i < G->n; i++)
		if (!visited[i])
			BFS2(G, i);
}


//打印邻接矩阵
void print_MTgraph(MTGraph *G) {
	int i, j;
	printf("  ");
	for (i = 0; i < G->n; i++) {
		printf("%d ", i);
	}
	printf("\n");
	for (i = 0; i < G->n; i++) {
		printf("%d ",i);
		for (j = 0; j < G->n; j++) {
			printf("%d ", G->edge[i][j]);
			if (j == G->n - 1) {
				printf("\n");
			}
		}
	}
}
//打印邻接表
void print_adjgraph(AdjGraph *G) {
	int i;
	EdgeNode *anode;
	for (i = 0; i < G->n; i++) {
		printf("%d->", G->vexlist[i].vertex);
		anode = G->vexlist[i].firstedge;
		while (anode != NULL) {
			if (anode->next != NULL) {
				printf("%d->", anode->adjvex);
				anode = anode->next;
			}
			else {
				printf("%d\n", anode->adjvex);
				anode = anode->next;
			}
		}
	}
}
//邻接矩阵空间占用情况
void use_mt(MTGraph *G) {
	int i = (int)(G->n*G->n*sizeof(int));
	printf("邻接矩阵空间占用情况：%d\n", i);
}
//邻接表空间占用情况
void use_adj(AdjGraph *G) {
	int i = (int)(G->n * sizeof(VertexNode) + G->e * sizeof(EdgeNode));
	printf("邻接表空间占用情况：%d\n", i);
}

//主函数
int main() {
	FILE *fp = fopen("G:\\graph.txt", "r");
	FILE *fp1 = fopen("G:\\adjgraph.txt", "r");
	FILE *fp2 = fopen("G:\\udggraph.txt", "r");
	MTGraph G;
	AdjGraph G1;
	CreateMGraph(&G, fp);
	CreateGraph(&G1, fp1);
	printf("打印邻接矩阵：\n");
	print_MTgraph(&G);
	printf("打印邻接表：\n");
	print_adjgraph(&G1);
	printf("邻接矩阵转化为邻接表：\n");
	print_adjgraph(&G1);
	printf("邻接表转化为邻接矩阵：\n");
	print_MTgraph(&G);
	printf("\n");
	use_mt(&G);
	use_adj(&G1);
	printf("\n");
	printf("邻接矩阵深度优先搜索递归：");
	DFSTraverse1(&G);
	printf("\n");
	printf("邻接表深度优先搜索递归：");
	DFSTraverse2(&G1);
	printf("\n");
	printf("\n");
	printf("邻接矩阵深度优先搜索非递归：");
	DFS11(&G);
	printf("\n");
	printf("邻接表深度优先搜索非递归：");
	DFS22(&G1);
	printf("\n");
	printf("\n");
	printf("邻接矩阵广度优先搜索：");
	BFSTraverse1(&G);
	printf("\n");
	printf("邻接表广度优先搜索：");
	BFSTraverse2(&G1);
	printf("\n");
	printf("\n");
	system("pause");
}

adjgraph
10 13
0,1 0,3 0,4 0,5 0,9 1,2 2,3 3,4 4,5 5,6 6,7 7,8 8,9

graph
10 13
0,1 0,3 0,4 0,5 0,9 1,2 2,3 3,4 4,5 5,6 6,7 7,8 8,9

udggraph
10 13
0,1 0,3 0,4 0,5 0,9 1,2 2,3 3,4 4,5 5,6 6,7 7,8 8,9