Question

以下是用于形成图表的邻接列表的实现。我不知道如何访问此列表并循环它以实现一些目标（例如DFS搜索）。

我尝试做graph[i][j]之类的事情，但编译器会说这是一个错误

下标值既不是数组也不是指针

我认为这里的图表只是一个指向另一个列表的指针。

我该怎么办？

注意：我无法正确格式化代码，因此我选择使用粘贴垃圾箱，不便之处。

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

#include "graph.h"

/* helper function prototypes */

// create a new vertex with a specific label
Vertex* new_vertex(const char* name);

// create a new w-weighted edge from vertex id u to vertex id v
Edge* new_edge(int u, int v, int w);

// destroy a vertex, including its label and all of its edges
void free_vertex(Vertex* vertex);


/* function definitions */

// create a new, empty graph, with space for n vertices
Graph* new_graph(int n) {
    Graph* graph = malloc(sizeof (*graph));
    assert(graph);

    graph->n = 0;
    graph->maxn = n;

    graph->vertices = malloc(n * sizeof (Vertex*));
    assert(graph->vertices);

    return graph;
}

// create a new vertex with a specific label
Vertex* new_vertex(const char* label) {
    assert(label);

    Vertex* vertex = malloc(sizeof (*vertex));
    assert(vertex);

    // make sure to copy the label across
    vertex->label = malloc((1 + strlen(label)) * sizeof (char));
    assert(vertex->label);
    strcpy(vertex->label, label);

    vertex->first_edge = NULL;

    return vertex;
}

// create a new w-weighted edge from vertex id u to vertex id v
Edge* new_edge(int u, int v, int w) {
    Edge* edge = malloc(sizeof (*edge));
    assert(edge);

    edge->u = u;
    edge->v = v;
    edge->weight = w;

    edge->next_edge = NULL;

    return edge;
}

// destroy a graph, its vertices, and their edges
void free_graph(Graph* graph) {
    if (graph) {
        int i;
        for (i = 0; i < graph->n; i++) {
            free_vertex(graph->vertices[i]);
        }

        free(graph->vertices);
        free(graph);    
    }
}

// destroy a vertex, including its label and all of its edges
void free_vertex(Vertex* vertex) {
    if (vertex) {
        while (vertex->first_edge) {
            Edge* edge = vertex->first_edge;
            vertex->first_edge = vertex->first_edge->next_edge;
            free(edge);
        }
        free(vertex->label);
        free(vertex);   
    }
}

// add a new vertex with label 'name' to a graph
void graph_add_vertex(Graph* graph, const char* name) {
    if (graph->n < graph->maxn) {
        graph->vertices[graph->n] = new_vertex(name);   
        graph->n++;
    } else {
        fprintf(stderr, "hey! adding new vertex to full graph\n");
    }
}

// add an undirected edge between u and v with weight w to graph
void graph_add_u_edge(Graph* graph, int u, int v, int w) {
    // an undirected edge is just two directed edges
    graph_add_d_edge(graph, u, v, w);
    graph_add_d_edge(graph, v, u, w);
}

// add a directed edge from u to v with weight w to a graph
void graph_add_d_edge(Graph* graph, int u, int v, int w) {
    if(u < graph->n && u >= 0 && v < graph->n && v >= 0) {
        Edge* edge = new_edge(u, v, w);
        edge->next_edge = graph->vertices[u]->first_edge;
        graph->vertices[u]->first_edge = edge;
    } else {
        fprintf(stderr, "hey! adding edge between non-existant vertices\n");
    }
}

graph.h

#ifndef GRAPH_H
#define GRAPH_H

typedef struct graph Graph;
typedef struct vertex Vertex;
typedef struct edge Edge;

// a graph knows its order (number of vertices) and an array of pointers to
// those vertices.
// these values can be used, but should not be *modified* outside of graph.c. 
// they are read-only!
struct graph {
    int n, maxn;
    Vertex** vertices;
};

// a vertex has a label and a pointer to the first edge in its adjacency list.
// these values can be used, but should not be *modified* outside of graph.c. 
// they are read-only!
struct vertex {
    char* label;
    Edge* first_edge;
};

// an edge knows the IDs of its two incident vertices; from u, to v
// each edge also knows its weight, and points to the next edge in a list of
// edges from the same vertex (or to NULL if it's the last edge in the list).
// these values can be used, but should not be *modified* outside of graph.c. 
// they are read-only!
struct edge {
    int u, v;
    int weight;
    Edge* next_edge;
};

// create a new, empty graph, with space for a maximum of n vertices
Graph* new_graph(int n);

// destroy a graph, its vertices, and their edges
void free_graph(Graph* graph);


// add a new vertex with label 'name' to a graph
void graph_add_vertex(Graph* graph, const char* name);

// add an undirected edge between u and v with weight w to graph
void graph_add_u_edge(Graph* graph, int u, int v, int w);

// add a directed edge from u to v with weight w to a graph
void graph_add_d_edge(Graph* graph, int u, int v, int w);

#endif

Answer 1

您的graph是指向Graph对象的指针。该对象具有成员vertices，一个指向Vertex个对象的指针数组。因此，顶点位于graph->vertices，顶点＃0位于graph->vertices[0]。

每个顶点都有一个成员first_edge，它是指向其第一条边的指针。因此，顶点＃0的第一个边缘是graph->vertices[0]->first_edge，并且其权重例如是graph->vertices[0]->first_edge->weight。

邻接列表中的下一个边是第一个边next_edge（例如，graph->vertices[0]->first_edge->next_edge）。要查找所有边，您应该使用for循环处理列表，从graph->vertices[0]->first_edge开始并继续next_edge，直到next_edge为0。

for(Edge *current = graph->vertices[0]->first_edge; 
    current;
    current = current->next_edge) {
    do_something_with(current);
}

希望它有所帮助。

如何访问和循环邻接列表？

1 个答案: