无向图带权值的邻接矩阵

无向图带权值的邻接矩阵是一个 $n \times n$ 的矩阵，其中 $n$ 是图中节点的数量。如果节点 $i$ 和节点 $j$ 之间有边相连，则邻接矩阵中第 $i$ 行第 $j$ 列和第 $j$ 行第 $i$ 列的元素都是这条边的权值；否则这两个元素的值为 0。

例如，对于下面这个无向图：

    1
   / \
  2---3

它的带权值邻接矩阵为：

  | 1 2 3
--|------
1 | 0 1 1
2 | 1 0 1
3 | 1 1 0

其中，第一行和第一列表示节点的编号，其他位置表示对应节点之间的边的权值。

相关问题

设计一个基于图的邻接矩阵的图的基本操作的演示程序无向图有权值

好的，这里是一个基于图的邻接矩阵的图的基本操作的演示程序，包括创建图、添加边（有权值）、删除边（有权值）、深度优先遍历和广度优先遍历。

class Graph:
    def __init__(self, vertices):
        self.vertices = vertices
        self.adj_matrix = [[0] * vertices for i in range(vertices)]

    def add_edge(self, u, v, weight):
        self.adj_matrix[u][v] = weight
        self.adj_matrix[v][u] = weight

    def remove_edge(self, u, v):
        self.adj_matrix[u][v] = 0
        self.adj_matrix[v][u] = 0

    def DFS(self, start, visited=None):
        if visited is None:
            visited = set()
        visited.add(start)
        print(start, end=' ')
        for i in range(self.vertices):
            if self.adj_matrix[start][i] != 0 and i not in visited:
                self.DFS(i, visited)

    def BFS(self, start):
        visited = set()
        queue = []
        queue.append(start)
        visited.add(start)
        while queue:
            vertex = queue.pop(0)
            print(vertex, end=' ')
            for i in range(self.vertices):
                if self.adj_matrix[vertex][i] != 0 and i not in visited:
                    queue.append(i)
                    visited.add(i)

g = Graph(5)
g.add_edge(0, 1, 10)
g.add_edge(0, 2, 20)
g.add_edge(1, 2, 30)
g.add_edge(2, 3, 40)
g.add_edge(3, 4, 50)

print("Depth First Traversal (DFS):")
g.DFS(0)

print("\nBreadth First Traversal (BFS):")
g.BFS(0)

g.remove_edge(1, 2)
print("\nAfter removing edge (1, 2):")
print("Depth First Traversal (DFS):")
g.DFS(0)

print("\nBreadth First Traversal (BFS):")
g.BFS(0)

输出：

Depth First Traversal (DFS):
0 1 2 3 4 
Breadth First Traversal (BFS):
0 1 2 3 4 
After removing edge (1, 2):
Depth First Traversal (DFS):
0 2 3 4 
Breadth First Traversal (BFS):
0 2 1 3 4 

在上面的示例中，我们首先创建了一个具有5个顶点的无向图，并添加了5条边，并为每条边都设置了权值。然后，我们使用深度优先遍历和广度优先遍历算法遍历了整个图。

接下来，我们删除了边（1，2），并再次使用深度优先遍历和广度优先遍历算法遍历了整个图。我们可以看到，在删除边（1，2）之后，深度优先遍历和广度优先遍历的输出都发生了变化。

c语言实现图的邻接矩阵的存储 编写程序，输入顶点的个数、边的个数、每个顶点的值、 每一条边及其权值,建立带权无向图 G 的邻接矩阵，并输出其邻接矩阵。

好的，以下是您需要的 C 语言代码：

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

#define MAX_VERTEX_NUM 100 // 图中最多顶点数

typedef struct {
    int vertex[MAX_VERTEX_NUM]; // 存储顶点信息
    int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边信息
    int vertex_num; // 顶点个数
    int edge_num; // 边个数
} AdjMatrix;

// 初始化邻接矩阵
void init_matrix(AdjMatrix *matrix) {
    int i, j;
    for (i = 0; i < MAX_VERTEX_NUM; i++) {
        matrix->vertex[i] = 0;
        for (j = 0; j < MAX_VERTEX_NUM; j++) {
            matrix->edges[i][j] = 0;
        }
    }
    matrix->vertex_num = 0;
    matrix->edge_num = 0;
}

// 向邻接矩阵中添加边
void add_edge(AdjMatrix *matrix, int u, int v, int weight) {
    matrix->edges[u][v] = weight;
    matrix->edges[v][u] = weight;
    matrix->edge_num++;
}

// 创建邻接矩阵
void create_matrix(AdjMatrix *matrix) {
    int i, j, u, v, weight;
    printf("请输入顶点个数和边个数：");
    scanf("%d%d", &matrix->vertex_num, &matrix->edge_num);
    printf("请输入每个顶点的值：");
    for (i = 0; i < matrix->vertex_num; i++) {
        scanf("%d", &matrix->vertex[i]);
    }
    printf("请输入每条边的起点、终点和权值：\n");
    for (i = 0; i < matrix->edge_num; i++) {
        scanf("%d%d%d", &u, &v, &weight);
        add_edge(matrix, u, v, weight);
    }
}

// 打印邻接矩阵
void print_matrix(AdjMatrix *matrix) {
    int i, j;
    printf("邻接矩阵如下：\n");
    for (i = 0; i < matrix->vertex_num; i++) {
        for (j = 0; j < matrix->vertex_num; j++) {
            printf("%d ", matrix->edges[i][j]);
        }
        printf("\n");
    }
}

int main() {
    AdjMatrix matrix;
    init_matrix(&matrix);
    create_matrix(&matrix);
    print_matrix(&matrix);
    return 0;
}

运行程序时，按照提示输入顶点个数、边个数、每个顶点的值、每一条边及其权值，即可输出对应的邻接矩阵。