c - C中的静态分配邻接矩阵图

我想在邻接矩阵中放置以下图形：
左图是8节点网络的节点链接表示。右边是同一网络的邻接矩阵表示。数量
灰色单元格等于图中的链接数。
所以我想做一个静态分配邻接矩阵。在C language中，什么是最好的方法？
我在想：

int Matrix[8][8];

如果该节点已连接到其他节点，则指定1；如果未连接，则指定0。我还想保留一个计数器来计算一个节点有多少个邻居，比如a有2个，B有3个。。。
但所有这些我都想是静态的而不是动态的。

最佳答案

在C99中，使用enum和“指定的初始值设定项”：

enum { A, B, C, D, E, F, G, H };

static const int Matrix[8][8] =
{
    [A] = { [B] = 1, [C] = 1 },
    [B] = { [A] = 1, [C] = 1, [D] = 1 },
    [C] = { [B] = 1, [F] = 1 },
    [D] = { [H] = 1 },
    [E] = { [D] = 1, [F] = 1, [G] = 1 },
    [F] = { [E] = 1, [G] = 1 },
    [G] = { [F] = 1, [H] = 1 },
    [H] = { [E] = 1, [G] = 1 },
};

这是你提供的表格的直接抄本；我还没有根据图表来验证表格。当然，没有显式初始值设定项的元素是零的。你可以决定把右大括号对齐，尽管这不是必要的；我很可能会。
如果不支持C99，则需要手动填充二维数组：

static const int Matrix[8][8] =
{  /* A  B  C  D  E  F  G  H */
    { 0, 1, 1, 0, 0, 0, 0, 0 }, /* A */
    { 1, 0, 1, 1, 0, 0, 0, 0 }, /* B */
    { 0, 1, 0, 0, 0, 1, 0, 0 }, /* C */
    { 0, 0, 0, 0, 0, 0, 0, 1 }, /* D */
    { 0, 0, 0, 1, 0, 1, 1, 0 }, /* E */
    { 0, 0, 0, 0, 1, 0, 1, 0 }, /* F */
    { 0, 0, 0, 0, 0, 1, 0, 1 }, /* G */
    { 0, 0, 0, 0, 1, 0, 1, 0 }, /* H */
};

如果图形以某种文本形式呈现，可以编写Perl、Python或Awk脚本（仅命名三种合适的语言）来自动生成输出。
注意：如果您想保留一个元素拥有的邻居数量的计数器（我假设，这意味着可以从这个节点到达的邻居数量，而不是可以到达这个节点的邻居数量-或者向外箭头，而不是向内箭头），那么您需要一个比简单的2D数组更复杂的结构。您可能会使用一组结构：

enum { A, B, C, D, E, F, G, H };
enum { MAX_GRAPH_SIZE = 8 };

typedef struct Node
{
    unsigned char n_out;
    unsigned char nodes[MAX_GRAPH_SIZE];
} Node;

static const Node Matrix[MAX_GRAPH_SIZE] =
{
    [A] = { .n_out = 2, .nodes = { [B] = 1, [C] = 1          } },
    [B] = { .n_out = 3, .nodes = { [A] = 1, [C] = 1, [D] = 1 } },
    [C] = { .n_out = 2, .nodes = { [B] = 1, [F] = 1          } },
    [D] = { .n_out = 1, .nodes = { [H] = 1                   } },
    [E] = { .n_out = 3, .nodes = { [D] = 1, [F] = 1, [G] = 1 } },
    [F] = { .n_out = 2, .nodes = { [E] = 1, [G] = 1          } },
    [G] = { .n_out = 2, .nodes = { [F] = 1, [H] = 1          } },
    [H] = { .n_out = 2, .nodes = { [E] = 1, [G] = 1          } },
};

我完全不相信，与计算出（或进入）一个节点的箭头数量相比，节省了额外的复杂性。值得注意的是，当引用数组的元素时，您现在必须编写：

Matrix[i].nodes[j]

而不是简单的：

Matrix[i][j]

关于c - C中的静态分配邻接矩阵图，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/6169164/