数据结构图的代码展示：

C++环境，使用c++的&引用符号：

#define _CRT_SECURE_NO_WARNINGS 1

#define MaxInt 32767 //表示极大值，即∞
#define MVNum 100 //最大顶点数
#define OK 0
#define OVERFLOW -1
#define ERROR -2

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

typedef char VerTexType; //假设顶点的数据类型为字符型
typedef int ArcType; //假设边的权值类型为整型
typedef int Stasus;

typedef struct {
	VerTexType vexs[MVNum]; //顶点表
	ArcType arcs[MVNum][MVNum]; //邻接矩阵
	int vexnum, arcnum; //图的当前点数和边数
}AMGraph;

int LocateVex(AMGraph G, VerTexType u)
{//存在则返回 u 在顶点表中的下标;否则返回-1
	int i;
	for (i = 0;i < G.vexnum;++i) {
		if (u == G.vexs[i]) {
			return i;
		}
	}
	return -1;
}
Stasus CreateUDN(AMGraph& G)
{ //采用邻接矩阵表示法，创建无向网 G
	int v1, v2,w;
	int a = 1;
	while (a) {
		printf("输入总顶点数，总边数\n");
		scanf("%d %d", &G.vexnum, &G.arcnum);//输入总顶点数，总边数
		if (G.vexnum * (G.vexnum - 1) < 2 * G.arcnum) {
			printf("输入有误，2倍边数不能大于顶点数*顶点数减一,请重新输入\n");
			while (getchar() != '\n');
		}
		else {
			a = 0;
		}
	}
	printf("输入点的信息\n");
	getchar();
	for (int i = 0; i < G.vexnum; ++i)
		scanf("%c",&G.vexs[i]); //依次输入点的信息
	while (getchar() != '\n');
	for (int i = 0; i < G.vexnum;++i) { //初始化邻接矩阵，边的权值均置为极大值
		for (int j = 0; j < G.vexnum;++j) {
			G.arcs[i][j] = MaxInt;
		}
	}
	printf("构造邻接矩阵,输入边依附的顶点及权值");
	for (int k = 0; k < G.arcnum;++k) //构造邻接矩阵
	{
		int c = k + 1;
		printf("请输入第%d条边\n", c);
		scanf("%c%c %d",&v1, &v2, &w); //输入一条边依附的顶点及权值
		int i = LocateVex(G, v1); int j = LocateVex(G, v2); //确定 v1 和 v2 在 G 中的位置
		if (i == -1 || j == -1) {
			printf("输入有误，不存在边<%c,%c>,请重新输入输入边依附的顶点及权值：\n", v1, v2);
			k--;
			while (getchar() != '\n');
			continue;
		}
		else {
			G.arcs[i][j] = w; //边<v1, v2>的权值置为 w 
			G.arcs[j][i] = G.arcs[i][j]; //置<v1, v2>的对称边<v2, v1>的权值为 w 
		}
		while (getchar() != '\n');
	}
	return OK;
}


void DFS(AMGraph G, int v);//声明

bool visited[MVNum] = {false};//定义全局变量

void DFS_AM(AMGraph G, int v) //图 G 为邻接矩阵类型
{//深度优先遍历，从第v个顶点出发递归的深度优先遍历
	printf("%c", G.vexs[v]); 
	visited[v] = true; //访问第 v 个顶点
	int w;
	for ( w = 0; w < G.vexnum; w++) { //依次检查邻接矩阵 v 所在的行 
		if ((G.arcs[v][w] != MaxInt) && (!visited[w])) {
			DFS_AM(G, w);
		}//w 是 v 的邻接点，如果 w 未访问，则递归调用 DFS 
	}
}

void DFS(AMGraph G,int v)
{
	//深度优先遍历非联通图
	int a;
	for (a = 0; a < G.vexnum; a++) {
		visited[a] = false;
	}//访问标志化数组初始化
	DFS_AM(G, v);
	for (v = 0; v < G.vexnum; v++) {
		if (visited[v] == false) {
			DFS_AM(G, v);
		}
	}//对v的尚未访问的邻接顶点w递归调用DFS_AM(G, v);
}

Stasus FistAdjVex(AMGraph G, ArcType u) {
	for (int i = 0;i < G.vexnum;i++) {
		if (G.arcs[u][i] < MaxInt && visited[i] == 0) {
			return i;
		}
	}
	return -1;
}

Stasus NextAdjVex(AMGraph G, ArcType u, ArcType w) {
	for (int i = 0;i < G.vexnum;i++) {
		if (G.arcs[u][i] < MaxInt && visited[i] == 0) {
			return i;
		}
	}return -1;
}

typedef char QElemType;
typedef struct QNode {
	QElemType data;//数值域
	struct QNode* next;//指针域
}QNode;

typedef QNode* QueuePtr;

typedef struct {
	QueuePtr front;//对头指针
	QueuePtr rear;//队尾指针
}LinkQueue;

Stasus  InitQueue(LinkQueue& Q) {
	//建立空链队列
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));//开辟空间
	if (!Q.front)exit(OVERFLOW);//开辟失败
	Q.front->next = NULL;//初始化链队
	return OK;
}
Stasus EnQueue(LinkQueue& Q, QElemType e) {
	//插入元素e为队尾
	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
	if (!p)exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return OK;
}
//判断对是否为空
Stasus QueueEmpty(LinkQueue Q) {
	if (Q.front == Q.rear) {
		return OK;
	}
	else {
		return OVERFLOW;
	}
}
Stasus  DeQueue(LinkQueue& Q, QElemType& e) {
	//删除对头元素
	if (Q.front == Q.rear) return ERROR;
	QueuePtr p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;

	if (Q.rear == p) Q.rear = Q.front;
	free(p);
	return OK;
}

void BFS(AMGraph G, int v) //按广度优先非递归遍历连通图 G
{
	printf("%c",G.vexs[v]);
	visited[v] = true; //访问第 v 个顶点
	LinkQueue Q;
	InitQueue(Q); //辅助队列 Q 初始化，置空 
	EnQueue(Q, v); //顶点 v 进队列
	while (QueueEmpty(Q)) //队列非空
	{
		char u;
		DeQueue(Q, u); //队头元素出队列并置为 u 
		for (int w = FistAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)) // FirstAdjVex 和 NextAdjVex
			//函数需要自己补充完成
			if (!visited[w]) //w 为 u 的尚未访问的邻接顶点
			{
				printf("%c",G.vexs[w]);
				visited[w] = true;
				EnQueue(Q, G.vexs[w]); //顶点 w 进队列
			}
	}
	
}


void PrintGragh(AMGraph G){
	//{按照矩阵模式打印所有顶点和边} 
	printf("打印顶点表 :");
	for (int i = 0;i < G.vexnum;i++) {
		//顶点
		printf("%c ",G.vexs[i]);
	}
	printf("\n");
	for (int i = 0;i < G.vexnum;i++) {
		for (int j = 0;j < G.vexnum;j++) {
			//边
			if (G.arcs[i][j] == MaxInt) {
				printf("∞\t");
			}
			else {
				printf("%d\t", G.arcs[i][j]);
			}
		}
		printf("\n");
	}
}

Stasus OperateMenu() {
	printf("0退出,1广度优先,2深度优先，3按照矩阵模式打印所有顶点和边4.查寻顶点的度\n");
	return OK;
}

void du(AMGraph G,int a) {
	int count = 0;
	printf("%c的度为：", G.vexs[a]);
	for (int i = 0;i < G.vexnum;i++) {
		for (int j = 0;j < G.vexnum;j++) {
			if ((G.vexs[a] == G.vexs[i] )&& (G.vexs[i] != G.vexs[j])&&G.arcs[i][j]!= MaxInt) {
				count++;
			}
		}
	}
	printf("%d\n", count);
}

int main() {
	AMGraph G;;
	int a;
	int v;
	int c = 1;
	char b;
	CreateUDN(G);
	while (1) {
		while(getchar()!='\n');
		int c = 1;
		OperateMenu();
		scanf("%d", &a);
		switch (a)
		{
		case 0:
			return 0;
		case 2:
			printf("深度优先遍历，从第v个顶点出发递归的深度优先遍历 :");
			while (getchar() != '\n');
			scanf("%d", &v);
			while (c) {
				if (v < 0 || v >= G.vexnum) {
					printf("输入有误，请输入的值>=0&&<%d,请重新输入遍历起点：", G.vexnum);
					scanf("%d", &v);
				}
				else {
					c = 0;
				}
			}
			DFS(G, v);
			for (int i = 0;i < MVNum;i++) {
				visited[i] = false;
			}
			while (getchar() != '\n');
			break;
		case 1:
			printf("按广度优先非递归遍历连通图 G,访问第 v 个顶点 : ");
			while (getchar() != '\n');
			scanf("%d", &v);
			while (c) {
				if (v < 0 || v >= G.vexnum) {
					printf("输入有误，请输入的值>=0&&<%d,请重新输入遍历起点：", G.vexnum);
					scanf("%d", &v);
				}
				else {
					c = 0;
				}
			}
			BFS(G, v);
			for (int i = 0;i < MVNum;i++) {
				visited[i] = false;
			}
			while (getchar() != '\n');
			break;
		case 3:
			PrintGragh(G);
			break;
		case 4:
			printf("请输入要查询的顶点：");
			scanf("%d", &a);
			while (c) {

				if (a >= G.vexnum) {
					printf("输入索引过大，请重新输入\n");
					scanf("%d", &a);
				}
				else {
					c = 0;
				}
			}
			du(G, a);
			break;
		default:
			printf("输入有误，请重新输入：\n");
			break;
		}
	}
}