用c++写一个输入邻接矩阵的程序
时间: 2023-12-03 09:02:20 浏览: 44
以下是一个简单的 C++ 程序,可以输入邻接矩阵:
```cpp
#include <iostream>
using namespace std;
const int MAXN = 100; // 最大顶点数
int n; // 顶点数
int graph[MAXN][MAXN]; // 邻接矩阵
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> graph[i][j];
}
}
return 0;
}
```
这个程序首先输入顶点数 n,然后使用两个循环输入邻接矩阵。例如,输入以下邻接矩阵:
```
0 1 1
1 0 1
1 1 0
```
程序的输出应该是:
```
3
0 1 1
1 0 1
1 1 0
```
注意,这个程序没有对输入进行任何检查,如果输入不符合邻接矩阵的格式,程序可能会崩溃或输出错误的结果。在实际使用中,应该对输入进行适当的检查和错误处理。
相关问题
请用C++写一个基于邻接矩阵的广度优先遍历
以下是基于邻接矩阵的广度优先遍历的C语言实现:
```c
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 100 // 最大顶点数
typedef struct {
int vertex[MAX_VERTEX_NUM]; // 存储顶点的数组
int arc[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储邻接矩阵的二维数组
int vertex_num; // 顶点数
int edge_num; // 边数
} Graph;
typedef struct {
int data[MAX_VERTEX_NUM]; // 存储队列元素的数组
int front; // 队头指针
int rear; // 队尾指针
} Queue;
// 初始化队列
void InitQueue(Queue *Q) {
Q->front = Q->rear = 0;
}
// 判断队列是否为空
int IsEmpty(Queue *Q) {
return Q->front == Q->rear;
}
// 入队
void EnQueue(Queue *Q, int data) {
Q->data[Q->rear++] = data;
}
// 出队
int DeQueue(Queue *Q) {
return Q->data[Q->front++];
}
// 创建邻接矩阵图
void CreateGraph(Graph *G) {
printf("请输入图的顶点数和边数:");
scanf("%d %d", &G->vertex_num, &G->edge_num);
printf("请输入图的顶点信息:");
for (int i = 0; i < G->vertex_num; i++) {
scanf("%d", &G->vertex[i]);
}
// 初始化邻接矩阵
for (int i = 0; i < G->vertex_num; i++) {
for (int j = 0; j < G->vertex_num; j++) {
G->arc[i][j] = 0;
}
}
// 构建邻接矩阵
printf("请输入图的边信息:\n");
for (int k = 0; k < G->edge_num; k++) {
int i, j;
printf("请输入第%d条边的两个顶点序号:", k + 1);
scanf("%d %d", &i, &j);
G->arc[i][j] = 1;
G->arc[j][i] = 1;
}
}
// 广度优先遍历
void BFS(Graph *G, int v) {
Queue Q;
int visited[MAX_VERTEX_NUM] = {0}; // 标记数组,用于记录每个顶点是否被访问过
InitQueue(&Q); // 初始化队列
visited[v] = 1; // 标记v已经被访问
printf("%d ", G->vertex[v]); // 输出v的值
EnQueue(&Q, v); // 将v入队
while (!IsEmpty(&Q)) {
int u = DeQueue(&Q); // 出队
for (int w = 0; w < G->vertex_num; w++) {
if (G->arc[u][w] && !visited[w]) { // 若u和w之间有边且w未被访问过
visited[w] = 1; // 标记w已经被访问
printf("%d ", G->vertex[w]); // 输出w的值
EnQueue(&Q, w); // 将w入队
}
}
}
}
int main() {
Graph G;
CreateGraph(&G);
printf("广度优先遍历结果为:\n");
BFS(&G, 0);
printf("\n");
return 0;
}
```
以上就是基于邻接矩阵的广度优先遍历的C语言实现。
用c++写一个图的邻接矩阵和邻接表存储
以下是C++代码:
```cpp
#include <iostream>
#include <vector>
using namespace std;
// 定义图类
class Graph {
private:
int V; // 图的顶点数量
vector<vector<int>> adjMatrix; // 邻接矩阵存储
vector<vector<int>> adjList; // 邻接表存储
public:
// 构造函数
Graph(int V) {
this->V = V;
// 初始化邻接矩阵,元素值为0表示两个顶点不相邻
adjMatrix.resize(V, vector<int>(V, 0));
// 初始化邻接表,每个顶点对应一个vector存储与之相邻的顶点
adjList.resize(V);
}
// 添加一条边
void addEdge(int u, int v) {
// 邻接矩阵中两个顶点相邻就把元素值设为1
adjMatrix[u][v] = 1;
adjMatrix[v][u] = 1;
// 邻接表中将v添加到u的vector中,将u添加到v的vector中
adjList[u].push_back(v);
adjList[v].push_back(u);
}
// 打印邻接矩阵
void printAdjMatrix() {
cout << "邻接矩阵:" << endl;
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
cout << adjMatrix[i][j] << " ";
}
cout << endl;
}
}
// 打印邻接表
void printAdjList() {
cout << "邻接表:" << endl;
for (int i = 0; i < V; i++) {
cout << i << ": ";
for (int j = 0; j < adjList[i].size(); j++) {
cout << adjList[i][j] << " ";
}
cout << endl;
}
}
};
int main() {
Graph g(5); // 创建一个具有5个顶点的图
// 添加边
g.addEdge(0, 1);
g.addEdge(0, 4);
g.addEdge(1, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(2, 3);
g.addEdge(3, 4);
// 打印邻接矩阵和邻接表
g.printAdjMatrix();
g.printAdjList();
return 0;
}
```
输出结果:
```
邻接矩阵:
0 1 0 0 1
1 0 1 1 1
0 1 0 1 0
0 1 1 0 1
1 1 0 1 0
邻接表:
0: 1 4
1: 0 2 3 4
2: 1 3
3: 1 2 4
4: 0 1 3
```