igraph_error_t igraph_vs_all(igraph_vs_t *vs);

参数： 

返回值： 

另请参阅： 

此选择器按递增的顶点 ID 顺序包括给定图的所有顶点。

时间复杂度：O(1)。

igraph_error_t igraph_vs_adj(igraph_vs_t *vs,
                  igraph_integer_t vid, igraph_neimode_t mode);

此选择器选择给定顶点的所有相邻顶点。 mode 参数控制要选择的相邻顶点的类型。 从 igraph 0.4 版本开始，顶点按递增的顶点 ID 顺序访问。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_vs_nonadj(igraph_vs_t *vs, igraph_integer_t vid,
                     igraph_neimode_t mode);

给定顶点的所有非相邻顶点。 mode 参数控制要不选择的相邻顶点类型。 与 igraph_vs_adj() 选择 vid 的直接邻居不同，当前函数选择不是 vid 直接邻居的顶点。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

#include <igraph.h>

int main(void) {

    igraph_t g;
    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_integer_t size;

    /* empty graph, all vertices */
    igraph_empty(&g, 10, IGRAPH_DIRECTED);
    igraph_vs_nonadj(&vs, 0, IGRAPH_ALL);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId " ", size);
    igraph_vit_create(&g, vs, &vit);
    while (!IGRAPH_VIT_END(vit)) {
        printf("%" IGRAPH_PRId " ", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    /* full graph, no vertices */
    igraph_full(&g, 10, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    igraph_vs_nonadj(&vs, 0, IGRAPH_ALL);
    igraph_vit_create(&g, vs, &vit);
    while (!IGRAPH_VIT_END(vit)) {
        printf("%" IGRAPH_PRId " ", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);


    return 0;
}

igraph_error_t igraph_vs_none(igraph_vs_t *vs);

创建空顶点选择器。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_vs_1(igraph_vs_t *vs, igraph_integer_t vid);

此顶点选择器选择单个顶点。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_vs_vector(igraph_vs_t *vs,
                     const igraph_vector_int_t *v);

此函数可以暂时将 igraph_vector_int_t 作为顶点选择器处理。 顶点选择器应被视为向量的视图。 如果你更改向量，也会影响顶点选择器。 销毁顶点选择器不会销毁向量。 在销毁顶点选择器之前不要销毁向量，否则可能会出现奇怪的行为。 由于选择器未与任何特定图相关联，因此此函数不检查向量中的顶点 ID 是否有效。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

#include <igraph.h>

int main(void) {

    igraph_t g;
    igraph_vector_int_t v = IGRAPH_VECTOR_NULL;
    igraph_integer_t edges[] = { 0, 1, 1, 2, 2, 2, 2, 3, 2, 4, 3, 4 };
    igraph_vector_int_t v2;
    igraph_integer_t i;
    igraph_vit_t vit;
    igraph_vs_t vs;
    igraph_integer_t size;

    igraph_vector_int_view(&v, edges, sizeof(edges) / sizeof(igraph_integer_t));
    igraph_create(&g, &v, 0, IGRAPH_DIRECTED);

    /* Create iterator based on a vector (view) */
    igraph_vector_int_init(&v2, 6);
    VECTOR(v2)[0] = 0;
    VECTOR(v2)[1] = 2;
    VECTOR(v2)[2] = 4;
    VECTOR(v2)[3] = 0;
    VECTOR(v2)[4] = 2;
    VECTOR(v2)[5] = 4;

    igraph_vit_create(&g, igraph_vss_vector(&v2), &vit);

    i = 0;
    while (!IGRAPH_VIT_END(vit)) {
        if (IGRAPH_VIT_GET(vit) != VECTOR(v2)[i]) {
            return 1;
        }
        IGRAPH_VIT_NEXT(vit);
        i++;
    }
    if (i != igraph_vector_int_size(&v2)) {
        return 2;
    }

    igraph_vit_destroy(&vit);
    igraph_vector_int_destroy(&v2);

    /* Create small vector iterator */

    igraph_vs_vector_small(&vs, 0, 2, 4, 0, 2, 4, 2, -1);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId " ", size);
    for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        printf("%" IGRAPH_PRId " ", IGRAPH_VIT_GET(vit));
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);

    /* Clean up */

    igraph_destroy(&g);

    return 0;
}

igraph_error_t igraph_vs_vector_small(igraph_vs_t *vs, ...);

此函数可用于创建具有一些顶点的顶点选择器。 不要忘记在最后一个顶点 ID 之后包含 -1。 如果你不正确地使用 -1，则该函数的行为是未定义的。

请注意，提供的顶点 ID 将解析为 int 类型的值，因此你不能在此处提供任意大的（对于 int 而言太大）顶点 ID。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(n)，提供的顶点 ID 数。

igraph_error_t igraph_vs_vector_copy(igraph_vs_t *vs, const igraph_vector_int_t *v);

此函数可以永久地将 igraph_vector_int_t 作为顶点选择器处理。 顶点选择器创建原始向量的副本，因此可以在创建顶点选择器后安全地销毁向量。 更改原始向量不会影响顶点选择器。 顶点选择器负责删除自身制作的副本。 由于选择器未与任何特定图相关联，因此此函数不检查向量中的顶点 ID 是否有效。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_vs_range(igraph_vs_t *vs, igraph_integer_t start, igraph_integer_t end);

创建顶点选择器，其中包含顶点 ID 等于或大于 from 且小于 to 的所有顶点。 请注意，按照 C 约定，间隔从左侧闭合，从右侧打开。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

#include <igraph.h>

int main(void) {

    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_t g;
    igraph_integer_t size;

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);
    igraph_vs_range(&vs, 0, 10);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId "", size);

    while (!IGRAPH_VIT_END(vit)) {
        printf(" %" IGRAPH_PRId "", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    return 0;
}

igraph_error_t igraph_vs_copy(igraph_vs_t* dest, const igraph_vs_t* src);

参数： 

void igraph_vs_destroy(igraph_vs_t *vs);

当不需要顶点选择器时，应为所有顶点选择器调用此函数。 将释放为顶点选择器分配的内存。 不要对使用顶点选择器构造函数的立即版本（以 igraph_vss 开头）创建的顶点选择器调用此函数。

参数： 

时间复杂度：取决于操作系统，通常为 O(1)。

igraph_bool_t igraph_vs_is_all(const igraph_vs_t *vs);

此函数检查顶点选择器对象是否由 igraph_vs_all() 或 igraph_vss_all() 创建。 请注意，顶点选择器可能包含给定图中的所有顶点，但如果它不是由此处提到的两个构造函数创建的，则返回值将为 false。

参数： 

返回值： 

时间复杂度：O(1)。

igraph_error_t igraph_vs_size(const igraph_t *graph, const igraph_vs_t *vs,
                   igraph_integer_t *result);

顶点选择器的大小是在迭代时将产生的顶点数。

参数： 

igraph_vs_t igraph_vss_all(void);

图中所有顶点的立即顶点选择器。 当应为所有顶点计算某些顶点属性（例如，介数、度等）时，可以方便地使用它。

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_vs_t igraph_vss_none(void);

空顶点选择器的立即版本。

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_vs_t igraph_vss_1(igraph_integer_t vid);

单顶点选择器的立即版本。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_vs_t igraph_vss_vector(const igraph_vector_int_t *v);

这是 igraph_vs_vector 的立即版本。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_vs_t igraph_vss_range(igraph_integer_t start, igraph_integer_t end);

igraph_vs_range() 的立即版本。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_vit_create(const igraph_t *graph, igraph_vs_t vs, igraph_vit_t *vit);

此函数使用给定的图实例化顶点选择器对象。 这是根据图从顶点选择器的逻辑概念创建实际顶点 ID 的步骤。 例如，使用 igraph_vs_all() 创建的顶点选择器包含所有顶点都包含在（尚未确定的）图中的知识。 实例化顶点迭代器对象时，将创建顶点迭代器对象，该对象包含作为参数提供的图中的实际顶点 ID。

同一顶点选择器对象可用于实例化任意数量的顶点迭代器。

参数： 

返回值： 

另请参阅： 

时间复杂度：取决于顶点选择器类型。 对于使用 igraph_vs_all()、igraph_vs_none()、igraph_vs_1、igraph_vs_vector、igraph_vs_range()、igraph_vs_vector()、igraph_vs_vector_small() 创建的顶点选择器，复杂度为 O(1)。 对于 igraph_vs_adj()，复杂度为 O(d)，d 是要包含在迭代器中的顶点 ID 数。 对于 igraph_vs_nonadj()，复杂度为 O(|V|)，|V| 是图中顶点的数量。

void igraph_vit_destroy(const igraph_vit_t *vit);

释放为顶点迭代器分配的内存。

参数： 

另请参阅： 

时间复杂度：取决于操作系统，通常为 O(1)。

使用 igraph_vit_create() 创建迭代器后，它指向由顶点选择器确定的顶点中的第一个顶点（如果有）。 IGRAPH_VIT_NEXT() 宏步进到下一个顶点，IGRAPH_VIT_END() 检查是否还有要访问的顶点，IGRAPH_VIT_SIZE() 给出了到目前为止已访问和要访问的顶点的总大小。 IGRAPH_VIT_RESET() 重置迭代器，它将再次指向第一个顶点。 最后，IGRAPH_VIT_GET() 给出了迭代器指向的当前顶点（仅当 IGRAPH_VIT_END() 为 false 时才调用它）。

以下是如何步进顶点 0 的邻居的示例

igraph_vs_t vs;
igraph_vit_t vit;
...
igraph_vs_adj(&vs, 0, IGRAPH_ALL);
igraph_vit_create(&graph, vs, &vit);
while (!IGRAPH_VIT_END(vit)) {
  printf(" %" IGRAPH_PRId, IGRAPH_VIT_GET(vit));
  IGRAPH_VIT_NEXT(vit);
}
printf("\n");
...
igraph_vit_destroy(&vit);
igraph_vs_destroy(&vs);

#define IGRAPH_VIT_NEXT(vit)

将迭代器步进到下一个顶点。 仅当 IGRAPH_VIT_END() 返回 false 时才调用此函数。

参数： 

时间复杂度：O(1)。

#define IGRAPH_VIT_END(vit)

检查是否还有要步进的顶点。

参数： 

返回值： 

时间复杂度：O(1)。

#define IGRAPH_VIT_SIZE(vit)

给出顶点迭代器中顶点的数量。

参数： 

返回值： 

时间复杂度：O(1)。

#define IGRAPH_VIT_RESET(vit)

重置顶点迭代器。 调用此宏后，迭代器将指向第一个顶点。

参数： 

时间复杂度：O(1)。

#define IGRAPH_VIT_GET(vit)

给出迭代器指向的当前顶点的顶点 ID。

参数： 

返回值： 

时间复杂度：O(1)。

igraph_error_t igraph_es_all(igraph_es_t *es,
                  igraph_edgeorder_type_t order);

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_incident(igraph_es_t *es,
                       igraph_integer_t vid, igraph_neimode_t mode);

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_none(igraph_es_t *es);

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_1(igraph_es_t *es, igraph_integer_t eid);

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_all_between(
    igraph_es_t *es, igraph_integer_t from, igraph_integer_t to,
    igraph_bool_t directed
);

此函数采用一对顶点，并创建一个与这些顶点之间的所有边匹配的选择器。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_vector(igraph_es_t *es, const igraph_vector_int_t *v);

创建边选择器，该选择器用作包含边 ID 的向量的视图。 在销毁边选择器之前，请勿销毁向量。 由于选择器未与任何特定图相关联，因此此函数不检查向量中的边 ID 是否有效。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_range(igraph_es_t *es, igraph_integer_t start, igraph_integer_t end);

创建边选择器，其中包含边 ID 等于或大于 from 且小于 to 的所有边。 请注意，按照 C 约定，间隔从左侧闭合，从右侧打开。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_pairs(igraph_es_t *es, const igraph_vector_int_t *v,
                    igraph_bool_t directed);

给定顶点对之间的边将被包含在边选择中。顶点对必须在向量 v 中定义，向量的第一个元素是要选择的第一个边的第一个顶点，第二个元素是第一个边的第二个顶点，第三个元素是第二个边的第一个顶点，依此类推。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(n)，n 是被选择的边的数量。

#include <igraph.h>

int main(void) {

    igraph_t g;
    igraph_integer_t i;
    igraph_integer_t size;

    /* DIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);

    for (i = 0; i < 100; i++) {
        igraph_es_t es;
        igraph_eit_t it;
        igraph_es_pairs_small(&es, IGRAPH_DIRECTED,
                              0, 1, 0, 2, 0, 5, 0, 2, 0, 3, 0, 4, 0, 7, 0, 9, -1);
        igraph_eit_create(&g, es, &it);
        igraph_es_size(&g, &es, &size);
        IGRAPH_EIT_RESET(it);
        while (!IGRAPH_EIT_END(it)) {
            (void) IGRAPH_EIT_GET(it);
            IGRAPH_EIT_NEXT(it);
            size--;
        }
        if (size != 0) {
            return 1;
        }
        igraph_eit_destroy(&it);
        igraph_es_destroy(&es);
    }

    igraph_destroy(&g);

    /* UNDIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);

    for (i = 0; i < 100; i++) {
        igraph_es_t es;
        igraph_eit_t it;
        igraph_es_pairs_small(&es, IGRAPH_DIRECTED,
                              0, 1, 2, 0, 5, 0, 0, 2, 3, 0, 0, 4, 7, 0, 0, 9, -1);
        igraph_eit_create(&g, es, &it);
        IGRAPH_EIT_RESET(it);
        while (!IGRAPH_EIT_END(it)) {
            (void) IGRAPH_EIT_GET(it);
            IGRAPH_EIT_NEXT(it);
        }
        igraph_eit_destroy(&it);
        igraph_es_destroy(&es);
    }

    igraph_destroy(&g);

    return 0;
}

igraph_error_t igraph_es_pairs_small(igraph_es_t *es, igraph_bool_t directed, int first, ...);

给定顶点对之间的边将被包含在边选择中。顶点对必须作为函数调用的参数给出，第三个参数是第一个边的第一个顶点，第四个参数是第一个边的第二个顶点，第五个参数是第二个边的第一个顶点，依此类推。参数列表的最后一个元素必须是 -1，以表示参数列表的结束。

请注意，提供的顶点 ID 将被解析为 int，因此您不能在此处提供任意大的（对于 int 来说太大）顶点 ID。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(n)，n 是被选择的边的数量。

igraph_error_t igraph_es_path(igraph_es_t *es, const igraph_vector_int_t *v,
                   igraph_bool_t directed);

此函数接受一个顶点向量，并创建这些顶点之间的边的选择器。向量 {0, 3, 4, 7} 将选择边 (0 -> 3)，(3 -> 4)，(4 -> 7)。如果这些边不存在，则尝试使用此选择器创建迭代器将失败。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(n)，n 是顶点的数量。

igraph_error_t igraph_es_vector_copy(igraph_es_t *es, const igraph_vector_int_t *v);

此函数使得可以将 igraph_vector_int_t 永久地作为边选择器处理。 边选择器创建原始向量的副本，因此在创建边选择器后可以安全地销毁向量。 更改原始向量不会影响边选择器。 边选择器负责删除自己创建的副本。 由于选择器不与任何特定图相关联，因此此函数不检查向量中的边 ID 是否有效。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order);

所有边选择器的立即版本。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_es_t igraph_ess_none(void);

空边选择器的立即版本。

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_es_t igraph_ess_1(igraph_integer_t eid);

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_es_t igraph_ess_vector(const igraph_vector_int_t *v);

这是边 ID 向量边选择器的立即版本。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_es_t igraph_ess_range(igraph_integer_t start, igraph_integer_t end);

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_es_as_vector(const igraph_t *graph, igraph_es_t es,
                        igraph_vector_int_t *v);

在边选择器上调用此函数以将其转换为向量。 这仅适用于序列和向量选择器。 如果边在图中不存在，这将导致错误。

参数： 

时间复杂度：O(n)，n 是选择器中边的数量。

igraph_error_t igraph_es_copy(igraph_es_t* dest, const igraph_es_t* src);

参数： 

另请参阅： 

void igraph_es_destroy(igraph_es_t *es);

当不再需要边选择器时，请在此边选择器上调用此函数。 不要 在由立即构造函数创建的边选择器上调用此函数，这些边选择器不需要销毁。

参数： 

时间复杂度：取决于操作系统，通常为 O(1)。

igraph_bool_t igraph_es_is_all(const igraph_es_t *es);

参数： 

返回值： 

时间复杂度：O(1)。

igraph_error_t igraph_es_size(const igraph_t *graph, const igraph_es_t *es,
                   igraph_integer_t *result);

边选择器的大小是在迭代时将产生的边的数量。

参数： 

igraph_error_t igraph_eit_create(const igraph_t *graph, igraph_es_t es, igraph_eit_t *eit);

此函数基于边选择器和图创建边迭代器。

可以使用相同的边选择器来创建多个边迭代器，也可以用于不同的图。

参数： 

返回值： 

另请参阅： 

时间复杂度：取决于边选择器的类型。 对于由 igraph_es_all(), igraph_es_none(), igraph_es_1(), igraph_es_vector(), igraph_es_range() 创建的边选择器，时间复杂度为 O(1)。 对于 igraph_es_incident()，时间复杂度为 O(d)，其中 d 是顶点的关联边的数量。

void igraph_eit_destroy(const igraph_eit_t *eit);

参数： 

另请参阅： 

时间复杂度：取决于操作系统，通常为 O(1)。

就像顶点迭代器一样，提供了用于步进遍历边序列的宏：IGRAPH_EIT_NEXT() 转到下一条边，IGRAPH_EIT_END() 检查是否还有更多边要访问，IGRAPH_EIT_SIZE() 给出边序列中边的数量，IGRAPH_EIT_RESET() 将迭代器重置为第一条边，IGRAPH_EIT_GET() 返回当前边的 ID。

#define IGRAPH_EIT_NEXT(eit)

将迭代器步进到下一条边。 仅当 IGRAPH_EIT_END() 返回 false 时才调用此函数。

参数： 

时间复杂度：O(1)。

#define IGRAPH_EIT_END(eit)

检查是否还有更多边要步进。

参数： 

返回值： 

时间复杂度：O(1)。

#define IGRAPH_EIT_SIZE(eit)

给出边迭代器中边的数量。

参数： 

返回值： 

时间复杂度：O(1)。

#define IGRAPH_EIT_RESET(eit)

重置边迭代器。 调用此宏后，迭代器将指向第一条边。

参数： 

时间复杂度：O(1)。

#define IGRAPH_EIT_GET(eit)

给出迭代器指向的当前边的边 ID。

参数： 

返回值： 

时间复杂度：O(1)。

igraph_error_t igraph_es_seq(igraph_es_t *es, igraph_integer_t from, igraph_integer_t to);

介于 from 和 to （包含）之间的所有边 ID 都将包含在边选择中。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_es_t igraph_ess_seq(igraph_integer_t from, igraph_integer_t to);

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

igraph_error_t igraph_vs_seq(igraph_vs_t *vs, igraph_integer_t from, igraph_integer_t to);

创建一个顶点选择器，其中包含顶点 ID 大于或等于 from 且小于或等于 to 的所有顶点。 请注意，与 C 约定相反，两个端点都是包含的。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。

#include <igraph.h>

int main(void) {

    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_t g;
    igraph_integer_t size;

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);
    igraph_vs_range(&vs, 0, 10);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId "", size);

    while (!IGRAPH_VIT_END(vit)) {
        printf(" %" IGRAPH_PRId "", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    return 0;
}

igraph_vs_t igraph_vss_seq(igraph_integer_t from, igraph_integer_t to);

igraph_vs_seq() 的立即版本。

参数： 

返回值： 

另请参阅： 

时间复杂度：O(1)。