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

Question

我想在下面的图表中加入一个邻接矩阵：

左图是8节点网络的节点链接表示。右边是同一网络的邻接矩阵表示。的数量 灰色单元格等于图表中的链接数。

所以我想制作一个静态分配的邻接矩阵。 C language中最好的方法是什么？

我在想这样的事情：

int Matrix[8][8];

然后在节点连接到其他节点时分配1，如果不连接则分配0。另外我还在考虑为一个节点的邻居数量保留一个计数器，比如A有2，B有3 ...

但所有这一切我都希望保持静态而不是动态。

Answer 1

在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支持，则可以手动填充2D阵列：

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脚本（仅限三种合适的语言）以自动为您生成输出。

---

注意：如果你想保留一个元素所具有的邻居数量的计数器（意思是，我假设，可以从该节点到达的邻居数量，而不是可以到达该节点的邻居数量） - 或箭头而不是箭头），那么你需要一个比简单的二维数组更复杂的结构。你可能会使用一系列结构：

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]