@【数据结构】（无向图）

@【数据结构】（无向图）

采用邻接矩阵实现无向图的存储，并输入输出邻接矩阵。求每个顶点的度，并实现图的广度优先遍历和深度优先遍历。

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<iomanip>
#define MAX 100
using namespace std;
typedef struct
{
	char vexs[100];    //顶点表
	int edges[100][100];       //邻接表，即边表
	int n, e;    //顶点数和边数
}MGraph;

typedef int Elemtype;
//数据结点
typedef struct node
{		/* 定义队列结构 */
	int data;		/* 队列元素类型为int */
	struct node *next;
}QNode;
//链队结点
typedef struct qptr
{
	QNode *front;
	QNode *rear;
}LQueue;
int EmptyQue(LQueue *q)//队列是否为空
{
	if (q->front == q->rear) return 0;
	else return 1;
}
void EnQueue(LQueue *q, int x)	/* 进队操作 */
{
	QNode *p;
	p = (QNode*)malloc(sizeof(QNode));
	p->data = x;  p->next = NULL;
	q->rear->next = p;
	q->rear = p;

}
int DeQueue(LQueue *q, int &x)	/* 出队操作 1:对空 */
{
	QNode *p;
	if (!EmptyQue(q))
	{
		cout << "队空" << endl; return 0;
	}
	else
	{
		p = q->front->next;
		q->front->next = p->next;
		x = p->data; free(p);
		if (q->front->next == NULL)
			q->rear = q->front;     //队中只有一个元素的情况下，出队后修改队尾指针
		return x;
	}
}
void createMG(MGraph &G)
{
	int n, e;
	int i, j, k;

	cout << "输入无向图的顶点数和边数：";
	cin >> n >> e;
	G.n = n; G.e = e;
	cout << "输入顶点名：" << endl;
	for (i = 0; i < G.n; i++)
		cin >> G.vexs[i];
	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
			G.edges[i][j] = 0;
	cout << "输入每条边对应的顶点序号（从0开始）：" << endl;
	for (k = 0; k < e; k++)
	{
		cin >> i >> j;
		G.edges[i][j] = 1;  //无向图的邻接矩阵
		G.edges[j][i] = 1;
	}
}

void outG(MGraph G)
{
	for (int i = 0; i < G.n; i++)
	{
		for (int j = 0; j < G.n; j++)
			if (G.edges[i][j] != 0)
				cout << setw(4) << G.edges[i][j];
			else if (i == j)  cout << setw(4) << "0";
			else cout << setw(4) << "∞";
		cout << endl;
	}

}
void Degree(MGraph G)
{

	for (int i = 0; i < G.n; i++)
	{
		int k = 0;
		for (int j = 0; j < G.n; j++)  //每一行非零元素个数等于第i个结点的度
			if (G.edges[i][j] != 0)
				k++;
		cout << "第" << i << "个顶点的度为" << k << endl;
	}
}
int visited[MAX] = { 0 };  //全局变量，值为0时表示未被访问，否则已被访问
//深度优先遍历
void DFSM(MGraph G, int i)
{
	int j;
	cout << G.vexs[i] << "  ";
	visited[i] = 1;   //标志已被访问
	for (j = 0; j < G.n; j++)
		if (G.edges[i][j] == 1 && !visited[j])  //有连接且没有被访问过
			DFSM(G, j);

}
void DFS(MGraph G)
{
	int i;
	for (i = 0; i < G.n; i++)
		visited[i] = 0;
	for (i = 0; i < G.n; i++)
		if (!visited[i])
			DFSM(G, i);
}
//广度优先遍历
void BFSM(MGraph G, int k)
{
	LQueue *q; QNode *p;
	q = (LQueue*)malloc(sizeof(LQueue));      //申请头、尾指针结点
	p = (QNode*)malloc(sizeof(QNode));        //申请链队头结点
	p->next = NULL;
	q->front = p; q->rear = p;

	int i, j;
	cout << G.vexs[k] << "  ";
	visited[k] = 1;   //标志已被访问
	EnQueue(q, k);
	while (!EmptyQue(q))
	{
		DeQueue(q, i);
		for (j = 0; i < G.n; j++)
			if (G.edges[i][j] == 1 && !visited[j])
			{
				cout << G.vexs[j] << "  ";
				visited[j] = 1;
				EnQueue(q, j);
			}
	}
}
void BFS(MGraph G)
{
	int i;
	for (i = 0; i < G.n; i++)
		visited[i] = 0;
	for (i = 0; i < G.n; i++)
		if (!visited[i])
			BFSM(G, i);
}
void main()
{
	MGraph G;
	createMG(G);
	cout << "输出邻接矩阵（∞表示不邻接）：" << endl;
	outG(G);
	cout << endl;
	cout << "求顶点的度：" << endl;
	Degree(G);
	cout << endl;
	cout << "深度优先遍历：" << endl;
	DFS(G);
	cout << endl;
	cout << "广度优先遍历：" << endl;
	//初始化一个带头结点的链队
	BFS(G);
	cout << endl;
	system("pause");
}

测试：
输入输出邻接矩阵：

求节点的度：

深度优先遍历及广度优先遍历：