图的不正确的邻接表表示

Question

我正在尝试使用图形的邻接表表示来表示图形。 我的代码编译正确但结果不正确，我似乎找不到合乎逻辑的 我的代码不一致。 这是一个示例输入和输出

Enter the number of Vertices 
 4

Enter the number of Edges
 6

输入边缘

0 1

1 2

2 3

3 0

0 2

1 3

顶点0的邻接表 头 -> 0-> 2

顶点1的邻接表 头 -> 1-> 3

顶点2的邻接表 头 -> 2

顶点3的邻接表 头 -> 3

这里注意0也和1相连

2 也连接到 1 和 0

struct grnode {

long long num;
struct grnode *next;
};

struct graph {

long long v;
long long e;
struct grnode *adj;
};

struct graph *adjlistgr(){

long long i,x,y;
struct grnode *temp;
struct graph *g = (struct graph*)malloc(sizeof(struct graph));
if (!g) {
    printf("memory error");
    return;
}
// here we scanf  the num of vertices and edges
printf("Enter the number of Vertices \n");
scanf("%lld", &g->v);
printf("Enter the number of Edges\n");
scanf("%lld", &g->e);
g->adj = malloc(g->v*sizeof(struct grnode));
for (i = 0; i < g->v; i++)
{

    g->adj[i].num = i;
    g->adj[i].next = &g->adj[i];
}
printf("Enter the Edges\n");
for (i = 0; i < g->e;i++)
{   // now we scan the edges

    scanf("%lld %lld", &x,&y);

    temp = (struct grnode*)malloc( sizeof( struct grnode*));
    temp->num = y;
    temp->next = &g->adj[x];
    g->adj[x].next = temp;
    temp = (struct grnode*)malloc( sizeof( struct grnode*));
    temp->num = y;
    temp->next = &g->adj[y];
    g->adj[y].next = temp;
}return g;
}

 void printgraph(struct graph* graph)
{                   

int n;                         
for (n = 0; n < graph->v; ++n)               
{                                      
    // struct grnode *pCrawl = graph->adj[n].num;
    struct grnode *temp;
    temp = (struct grnode*)malloc( sizeof( struct grnode*));
    temp->next=&graph->adj[n];
    temp=temp->next;
    printf("\n Adjacency list of vertex %d\n head ", n);
    long long s=temp->num;
    do 
    {
        printf("-> %d", temp->num);
        temp = temp->next;
    }while(temp->num!=s);
    printf("\n");
}}    
  int main(){      
  struct graph *mylist=adjlistgr();          
  printgraph(mylist);    
}

Answer 1

除了分配问题，您的数据组织还需要重新考虑。

您似乎也对malloc 有误解。例如，您在打印函数内部分配内存。该函数应该只检查数据然后打印它。分配是不必要的。在您的代码中，您会立即覆盖分配数据的句柄：

temp = (struct grnode*)malloc( sizeof( struct grnode*));
temp->next=&graph->adj[n];
temp=temp->next;

这意味着您将失去对新数据的访问权限（并且以后不能free 它）。这就像买房子把钥匙扔掉一样。一句话就够了：

temp = &graph->adj[n];

当您使用指针时，请记住：指针应该指向有效数据或者应该是NULL。分配内存时，不要更改该内存的句柄，并确保稍后通过该句柄free。

关于您的图表：您有四个节点。这些节点在初始化后就固定了。你不能在它们之间添加边，但你不能重复使用它们来做双重职责，作为应该是四个独立链表的元素。这就是您的代码想要做的事情。

有几种方法可以描述邻接。您可以在图形中添加一个矩阵，或者您可以制作一个包含两个连接节点并按图形组织的边结构。或者您可以为每个节点制作一个连接列表。选择一个。

重点是您的节点和边需要两个独立的数据结构。

编辑根据您使用链表表示连接的主要想法，我在下面为单向图实现了一个简单的框架。您可以看到每个grnode 都维护着自己的grconn 连接链表。该代码还展示了如何在使用后清理已使用的内存。

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

struct grnode;
struct grconn;

struct grconn {                 /* Connection to node (linked list) */
    struct grnode *dest;
    struct grconn *next;
};

struct grnode {                 /* Node in graph */
    int id;
    struct grconn *conn;
};

struct graph {
    int nnode;
    struct grnode *node;
};



/*
 *      Create new connection to given node
 */
struct grconn *grconn_new(struct grnode *nd)
{
    struct grconn *c = malloc(sizeof(*c));

    if (c) {
        c->dest = nd;
        c->next = NULL;
    }

    return c;
}

/*
 *      Clean up linked list of connections
 */
void grconn_delete(struct grconn *c)
{ 
    while (c) {
        struct grconn *p = c->next;

        free(c);
        c = p;
    }
}

/*
 *      Print connectivity list of a node
 */
void grnode_print(struct grnode *nd)
{
    struct grconn *c;

    printf("%d:", nd->id);

    c = nd->conn;
    while (c) {
        printf(" %d", c->dest->id);
        c = c->next;
    }

    printf("\n");
}



/*
 *      Create new graph with given number of nodes
 */
struct graph *graph_new(int n)
{
    struct graph *g = malloc(sizeof(*g));
    int i;

    if (g == NULL) return g;

    g->nnode = n;
    g->node = malloc(n * sizeof(*g->node));
    if (g->node == NULL) {
        free(g);
        return NULL;
    }

    for (i = 0; i < n; i++) {
        g->node[i].id = i;
        g->node[i].conn = NULL;
    }

    return g;
}

/*
 *      Delete graph and all dependent data
 */
void graph_delete(struct graph *g)
{
    int i;

    for (i = 0; i < g->nnode; i++) {
        grconn_delete(g->node[i].conn);
    }

    free(g->node);
    free(g);
}

/*
 *      Print connectivity of all nodes in graph
 */
void graph_print(struct graph *g)
{
    int i;

    for (i = 0; i < g->nnode; i++) {
        grnode_print(&g->node[i]);
    }
}

/*
 *      Create one-way connection from node a to node b
 */
void graph_connect(struct graph *g, int a, int b)
{
    struct grnode *nd;
    struct grconn *c;

    if (a < 0 || a >= g->nnode) return;
    if (b < 0 || b >= g->nnode) return;

    nd = &g->node[a];
    c = grconn_new(&g->node[b]);

    c->next = nd->conn;
    nd->conn = c;
}

/*
 *      Create two-way connection between nodes a and b
 */
void graph_connect_both(struct graph *g, int a, int b)
{
    graph_connect(g, a, b);
    graph_connect(g, b, a);
}



/*
 *      Example client code
 */
int main()
{
    struct graph *g = graph_new(4);

    graph_connect_both(g, 0, 1);
    graph_connect_both(g, 1, 2);
    graph_connect_both(g, 2, 3);
    graph_connect_both(g, 0, 2);
    graph_connect_both(g, 1, 3);

    graph_print(g);

    graph_delete(g);

    return 0;
}

Answer 2

表达式malloc( sizeof( struct grnode*)) 分配一个指针 并返回一个指向已分配指针的指针。如果你不使用它作为指向指针的指针，就像你没有那样，那么你有undefined behavior。

我怀疑你真的想要malloc( sizeof( struct grnode))。

顺便说一句，in C you should not cast the result of malloc。在 C++ 中，无论如何你都不应该使用 malloc。