写程序完成无向网的邻接矩阵存储结构的创建 1） 创建无向网的邻接矩阵 2） 输出该邻接矩阵

在编程中，特别是在使用像Python这样的语言时，我们可以创建一个二维数组来表示无向图的邻接矩阵。这个矩阵的行代表源节点，列代表目标节点，矩阵中的元素值表示两个节点之间是否有边连接。

以下是使用Python实现的一个简单例子：

# 定义一个函数用于创建邻接矩阵
def create_adjacency_matrix(vertices):
    # 初始化一个全0的邻接矩阵
    adjacency_matrix = [[0] * vertices for _ in range(vertices)]
    
    # 如果需要，你可以在此添加自定义的边或者邻居关系
    # 比如：
    # 添加边 (u, v)
    adjacency_matrix[u][v] = 1
    adjacency_matrix[v][u] = 1  # 由于无向图，从v到u也需要有边

    return adjacency_matrix

# 示例：假设我们有一个包含5个顶点的无向图
vertices = 5
adj_matrix = create_adjacency_matrix(vertices)

# 输出邻接矩阵
for row in adj_matrix:
    print(row)

# 结果类似：
# [0, 1, 1, 0, 0]
# [1, 0, 1, 1, 0]
# [1, 1, 0, 1, 1]
# [0, 1, 1, 0, 1]
# [0, 0, 1, 1, 0]

相关问题

使用c＋＋写程序完成无向网的邻接矩阵存储结构的创建 1） 创建无向网的邻接矩阵 2） 输出该邻接矩阵

在C++中，你可以使用二维数组或`std::vector<std::vector<int>>`来创建一个无向图的邻接矩阵表示。以下是简单的步骤：

1) **创建无向网的邻接矩阵**:

#include <iostream>
#include <vector>

// 定义邻接矩阵的数据结构
typedef std::vector<std::vector<int>> AdjacencyMatrix;

void createAdjacencyMatrix(int numVertices, AdjacencyMatrix& adjMatrix) {
    adjMatrix.resize(numVertices); // 初始化一个大小为numVertices的行向量
    for (int i = 0; i < numVertices; ++i) {
        adjMatrix[i].resize(numVertices); // 对每个节点，初始化列向量为全零
    }
}

// 添加边到邻接矩阵
void addEdge(int src, int dest, AdjacencyMatrix& adjMatrix, bool isDirected = false) {
    if (!isDirected) { // 如果图是无向的，则添加两个方向的边
        adjMatrix[src][dest] = 1; // 表示从src到dest有边
        adjMatrix[dest][src] = 1;
    } else {
        adjMatrix[src][dest] = 1; // 只添加一个方向的边
    }
}

int main() {
    int numVertices; // 图的顶点数
    std::cout << "Enter the number of vertices: ";
    std::cin >> numVertices;

    AdjacencyMatrix adjMatrix;
    createAdjacencyMatrix(numVertices, adjMatrix);

    int src, dest;
    std::cout << "Enter edges in the form (source vertex, destination vertex): \n";
    while (std::cin >> src >> dest) {
        addEdge(src, dest, adjMatrix);
    }

    return 0;
}

2) **输出邻接矩阵**:

void printAdjacencyMatrix(const AdjacencyMatrix& adjMatrix) {
    for (int i = 0; i < adjMatrix.size(); ++i) {
        std::cout << "Vertex " << i+1 << ": [";
        for (int j = 0; j < adjMatrix[i].size(); ++j) {
            std::cout << adjMatrix[i][j] << " ";
        }
        std::cout << "]" << std::endl;
    }
}

// 在main函数中调用此函数打印结果
printAdjacencyMatrix(adjMatrix);

使用c＋＋写程序完成无向网的邻接矩阵存储结构的创建 1） 创建无向网的邻接矩阵并输出该邻接矩阵

在C++中，你可以通过二维数组或者`std::vector`来实现无向图的邻接矩阵表示。这里是一个基本的例子，我们将使用`std::vector`来存储邻接矩阵：

#include <iostream>
#include <vector>

// 定义无向图节点数的最大值
const int MAX_NODES = 10;

class Graph {
private:
    std::vector<std::vector<int>> adjMatrix; // 邻接矩阵

public:
    Graph(int numNodes) {
        adjMatrix.resize(numNodes, std::vector<int>(numNodes, 0)); // 初始化全零矩阵
    }

    void addEdge(int src, int dest) {
        adjMatrix[src][dest] = 1; // 从源到目的边设置为1（无向图）
        adjMatrix[dest][src] = 1; // 反方向也设为1，因为是无向图
    }

    void printAdjMatrix() {
        for (int i = 0; i < MAX_NODES; ++i) {
            for (int j = 0; j < MAX_NODES; ++j) {
                if (adjMatrix[i][j] != 0)
                    std::cout << "1 ";
                else
                    std::cout << "0 ";
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
};

int main() {
    int numNodes;
    std::cout << "Enter the number of nodes in the graph: ";
    std::cin >> numNodes;

    Graph g(numNodes);
    
    // 添加一些边
    int edge;
    std::cout << "Enter edges (source vertex then destination vertex): \n";
    while (std::cin >> edge && edge >= 0 && edge < numNodes) {
        int src, dest;
        std::cin >> src >> dest;
        g.addEdge(src, dest);
    }

    g.printAdjMatrix();
    return 0;
}

在这个例子中，用户输入无向图的节点数和边的信息，然后程序会创建一个邻接矩阵，并打印出来。注意，这个邻接矩阵是二元的，非零元素表示两个节点之间有边。