查看源代码 gb_sets (stdlib v6.2)

用通用平衡树表示的集合。

此模块使用 Arne Andersson 教授的通用平衡树提供有序集合。对于较大的集合,有序集合可能比使用有序列表更有效,但这取决于具体的应用。

此模块使用的表示集合的数据,应被其他模块视为不透明的。抽象地说,该表示是现有 Erlang 项的复合类型。请参阅关于数据类型的注释。任何假设了解此格式的代码都存在风险。

当且仅当两个元素不相等(==)时,此模块才认为它们是不同的。

复杂度说明

集合操作的复杂度受限于 O(|S|)O(|T| log(|S|))*, 其中 S 是给定的最大集合,具体取决于哪个函数调用最快。对于大小几乎相等的集合进行操作,此实现比直接使用有序列表集合慢约 3 倍。但是,对于大小差异很大的集合,此解决方案可能快得多;在实际情况下,通常快 10-100 倍。此实现特别适合于一次累积几个元素,建立一个大型集合(> 100-200 个元素),并重复测试当前集合中的成员资格。

与正常的树结构一样,查找(成员资格测试)、插入和删除具有对数复杂度。

兼容性

有关标准库中不同集合实现的兼容性信息,请参阅 sets 模块中的兼容性部分

另请参阅

gb_trees, ordsets, sets

摘要

类型

通用的平衡集合迭代器。

通用的平衡集合。

函数

返回一个由插入了 ElementSet1 形成的新集合。如果 Element 已经是 Set1 中的元素,则不会发生任何更改。

重新平衡 Set1 的树表示形式。

返回一个由移除了 ElementSet1 形成的新集合。假设 Element 存在于 Set1 中。

返回一个由移除了 ElementSet1 形成的新集合。如果 Element 不是 Set1 中的元素,则不会发生任何更改。

返回一个新的空集合。

使用谓词函数 Pred 过滤 Set1 中的元素。

使用函数 Fun 过滤并映射 Set1 中的元素。

Function 折叠到 Set 中的每个元素上,返回累加器的最终值。

返回 List 中元素的集合,其中 List 可以是无序的并且包含重复项。

将有序集合列表 List 转换为集合。该列表不能包含重复项。

返回一个由插入了 ElementSet1 形成的新集合。假设 Element 不存在于 Set1 中。

返回非空集合列表的交集。

返回 Set1Set2 的交集。

如果 Set1Set2 不相交(没有共同元素),则返回 true,否则返回 false

如果 Set 是空集合,则返回 true,否则返回 false

如果 Set1Set2 相等,即一个集合的每个元素也是另一个集合的成员,则返回 true,否则返回 false

如果 ElementSet 的成员,则返回 true,否则返回 false

如果 Term 看起来像一个集合,则返回 true,否则返回 false。此函数将为任何与 gb_set 的表示形式一致的项返回 true,即使它实际上不是 gb_set,因此可能会返回假阳性结果。另请参阅关于数据类型的注释。

Set1 的每个元素也是 Set2 的成员时,返回 true,否则返回 false

返回一个可用于遍历 Set 条目的迭代器;请参阅 next/1

返回一个可用于以 orderedreversed 方向遍历 Set 条目的迭代器;请参阅 next/1

返回一个可用于遍历 Set 条目的迭代器;请参阅 next/1。与 iterator/1 返回的迭代器相比,不同之处在于迭代器从第一个大于或等于 Element 的元素开始。

返回一个可用于遍历 Set 条目的迭代器;请参阅 next/1。与 iterator/2 返回的迭代器相比,不同之处在于迭代器从第一个大于或等于 Element 的元素开始。

返回 {found, Element2},其中 Element2 是严格大于 Element1 的最小元素。

返回 Set 中最大的元素。假设 Set 不为空。

使用映射函数 Fun 映射 Set1 中的元素。

返回一个新的空集合。

返回 {Element, Iter2},其中 Element 是迭代器 Iter1 引用的最小元素,而 Iter2 是用于遍历剩余元素的新迭代器,如果没有剩余元素,则返回原子 none

返回一个仅包含元素 Element 的集合。

返回 Set 中的元素数量。

返回 {found, Element2},其中 Element2 是严格小于 Element1 的最大元素。

返回 Set 中最小的元素。假设 Set 不为空。

仅返回 Set1 中不也是 Set2 元素的元素。

返回 {Element, Set2},其中 ElementSet1 中最大的元素,而 Set2 是删除了 Element 的此集合。假设 Set1 不为空。

返回 {Element, Set2},其中 ElementSet1 中最小的元素,而 Set2 是删除了 Element 的此集合。假设 Set1 不为空。

Set 的元素作为列表返回。

返回集合列表的合并(并集)集合。

返回 Set1Set2 的合并(并集)集合。

类型

-type iter() :: iter(_).
-opaque iter(Element)

通用的平衡集合迭代器。

-type set() :: set(_).
-opaque set(Element)

通用的平衡集合。

函数

-spec add(Element, Set1) -> Set2 when Set1 :: set(Element), Set2 :: set(Element).

等同于 add_element(Element, Set1)

链接到此函数

add_element(Element, Set1)

查看源代码
-spec add_element(Element, Set1) -> Set2 when Set1 :: set(Element), Set2 :: set(Element).

返回一个由插入了 ElementSet1 形成的新集合。如果 Element 已经是 Set1 中的元素,则不会发生任何更改。

-spec balance(Set1) -> Set2 when Set1 :: set(Element), Set2 :: set(Element).

重新平衡 Set1 的树表示形式。

请注意,这很少有必要,但在从树中删除大量元素而没有进一步插入时,可以这样做。然后可以强制重新平衡以最小化查找时间,因为删除不会重新平衡树。

链接到此函数

del_element(Element, Set1)

查看源代码
-spec del_element(Element, Set1) -> Set2 when Set1 :: set(Element), Set2 :: set(Element).

等同于 delete_any(Element, Set1)

-spec delete(Element, Set1) -> Set2 when Set1 :: set(Element), Set2 :: set(Element).

返回一个由移除了 ElementSet1 形成的新集合。假设 Element 存在于 Set1 中。

链接到此函数

delete_any(Element, Set1)

查看源代码
-spec delete_any(Element, Set1) -> Set2 when Set1 :: set(Element), Set2 :: set(Element).

返回一个由移除了 ElementSet1 形成的新集合。如果 Element 不是 Set1 中的元素,则不会发生任何更改。

链接到此函数

difference(Set1, Set2)

查看源代码
-spec difference(Set1, Set2) -> Set3
                    when Set1 :: set(Element), Set2 :: set(Element), Set3 :: set(Element).

等同于 subtract(Set1, Set2)

-spec empty() -> Set when Set :: set(none()).

返回一个新的空集合。

-spec filter(Pred, Set1) -> Set2
                when Pred :: fun((Element) -> boolean()), Set1 :: set(Element), Set2 :: set(Element).

使用谓词函数 Pred 过滤 Set1 中的元素。

链接到此函数

filtermap(Fun, Set1)

查看源代码 (自 OTP 27.0 起)
-spec filtermap(Fun, Set1) -> Set2
                   when
                       Fun :: fun((Element1) -> boolean() | {true, Element2}),
                       Set1 :: set(Element1),
                       Set2 :: set(Element1 | Element2).

使用函数 Fun 过滤并映射 Set1 中的元素。

链接到此函数

fold(Function, Acc0, Set)

查看源代码
-spec fold(Function, Acc0, Set) -> Acc1
              when
                  Function :: fun((Element, AccIn) -> AccOut),
                  Acc0 :: Acc,
                  Acc1 :: Acc,
                  AccIn :: Acc,
                  AccOut :: Acc,
                  Set :: set(Element).

Function 折叠到 Set 中的每个元素上,返回累加器的最终值。

-spec from_list(List) -> Set when List :: [Element], Set :: set(Element).

返回 List 中元素的集合,其中 List 可以是无序的并且包含重复项。

-spec from_ordset(List) -> Set when List :: [Element], Set :: set(Element).

将有序集合列表 List 转换为集合。该列表不能包含重复项。

-spec insert(Element, Set1) -> Set2 when Set1 :: set(Element), Set2 :: set(Element).

返回一个由插入了 ElementSet1 形成的新集合。假设 Element 不存在于 Set1 中。

-spec intersection(SetList) -> Set when SetList :: [set(Element), ...], Set :: set(Element).

返回非空集合列表的交集。

链接到此函数

intersection(Set1, Set2)

查看源代码
-spec intersection(Set1, Set2) -> Set3
                      when Set1 :: set(Element), Set2 :: set(Element), Set3 :: set(Element).

返回 Set1Set2 的交集。

链接到此函数

is_disjoint(Set1, Set2)

查看源代码
-spec is_disjoint(Set1, Set2) -> boolean() when Set1 :: set(Element), Set2 :: set(Element).

如果 Set1Set2 不相交(没有共同元素),则返回 true,否则返回 false

链接到此函数

is_element(Element, Set)

查看源代码
-spec is_element(Element, Set) -> boolean() when Set :: set(Element).

等同于 is_member(Element, Set)

-spec is_empty(Set) -> boolean() when Set :: set().

如果 Set 是空集合,则返回 true,否则返回 false

链接到此函数

is_equal(Set1, Set2)

查看源代码 (自 OTP 27.0 起)
-spec is_equal(Set1, Set2) -> boolean() when Set1 :: set(), Set2 :: set().

如果 Set1Set2 相等,即一个集合的每个元素也是另一个集合的成员,则返回 true,否则返回 false

链接到此函数

is_member(Element, Set)

查看源代码
-spec is_member(Element, Set) -> boolean() when Set :: set(Element).

如果 ElementSet 的成员,则返回 true,否则返回 false

-spec is_set(Term) -> boolean() when Term :: term().

如果 Term 看起来像一个集合,则返回 true,否则返回 false。此函数将为任何与 gb_set 的表示形式一致的项返回 true,即使它实际上不是 gb_set,因此可能会返回假阳性结果。另请参阅关于数据类型的注释。

-spec is_subset(Set1, Set2) -> boolean() when Set1 :: set(Element), Set2 :: set(Element).

Set1 的每个元素也是 Set2 的成员时,返回 true,否则返回 false

-spec iterator(Set) -> Iter when Set :: set(Element), Iter :: iter(Element).

返回一个可用于遍历 Set 条目的迭代器;请参阅 next/1

等同于 iterator(Set, ordered)

链接到此函数

iterator(Set, Order)

查看源代码 (自 OTP 27.0 起)
-spec iterator(Set, Order) -> Iter
                  when Set :: set(Element), Iter :: iter(Element), Order :: ordered | reversed.

返回一个可用于以 orderedreversed 方向遍历 Set 条目的迭代器;请参阅 next/1

此实现的效率非常高;使用 next/1 遍历整个集合只比使用 to_list/1 获取所有元素的列表并遍历该列表稍慢。迭代器方法的主要优点是不需要在内存中一次性构建所有元素的完整列表。

链接到此函数

iterator_from(Element, Set)

查看源代码 (自 OTP 18.0 起)
-spec iterator_from(Element, Set) -> Iter when Set :: set(Element), Iter :: iter(Element).

返回一个可用于遍历 Set 条目的迭代器;请参阅 next/1。与 iterator/1 返回的迭代器相比,不同之处在于迭代器从第一个大于或等于 Element 的元素开始。

等同于 iterator_from(Element, Set, ordered)

链接到此函数

iterator_from(Element, Set, Order)

查看源代码 (自 OTP 27.0 起)
-spec iterator_from(Element, Set, Order) -> Iter
                       when Set :: set(Element), Iter :: iter(Element), Order :: ordered | reversed.

返回一个可用于遍历 Set 条目的迭代器;请参阅 next/1。与 iterator/2 返回的迭代器相比,不同之处在于迭代器从第一个大于或等于 Element 的元素开始。

链接到此函数

larger(Element1, Set)

查看源代码 (自 OTP 27.0 起)
-spec larger(Element1, Set) -> none | {found, Element2}
                when Element1 :: Element, Element2 :: Element, Set :: set(Element).

返回 {found, Element2},其中 Element2 是严格大于 Element1 的最小元素。

如果不存在此类元素,则返回 none

-spec largest(Set) -> Element when Set :: set(Element).

返回 Set 中最大的元素。假设 Set 不为空。

链接到此函数

map(Fun, Set1)

查看源代码 (自 OTP 27.0 起)
-spec map(Fun, Set1) -> Set2
             when Fun :: fun((Element1) -> Element2), Set1 :: set(Element1), Set2 :: set(Element2).

使用映射函数 Fun 映射 Set1 中的元素。

-spec new() -> Set when Set :: set(none()).

返回一个新的空集合。

-spec next(Iter1) -> {Element, Iter2} | none when Iter1 :: iter(Element), Iter2 :: iter(Element).

返回 {Element, Iter2},其中 Element 是迭代器 Iter1 引用的最小元素,而 Iter2 是用于遍历剩余元素的新迭代器,如果没有剩余元素,则返回原子 none

-spec singleton(Element) -> set(Element).

返回一个仅包含元素 Element 的集合。

-spec size(Set) -> non_neg_integer() when Set :: set().

返回 Set 中的元素数量。

链接到此函数

smaller(Element1, Set)

查看源代码 (自 OTP 27.0 起)
-spec smaller(Element1, Set) -> none | {found, Element2}
                 when Element1 :: Element, Element2 :: Element, Set :: set(Element).

返回 {found, Element2},其中 Element2 是严格小于 Element1 的最大元素。

如果不存在此类元素,则返回 none

-spec smallest(Set) -> Element when Set :: set(Element).

返回 Set 中最小的元素。假设 Set 不为空。

-spec subtract(Set1, Set2) -> Set3 when Set1 :: set(Element), Set2 :: set(Element), Set3 :: set(Element).

仅返回 Set1 中不也是 Set2 元素的元素。

-spec take_largest(Set1) -> {Element, Set2} when Set1 :: set(Element), Set2 :: set(Element).

返回 {Element, Set2},其中 ElementSet1 中最大的元素,而 Set2 是删除了 Element 的此集合。假设 Set1 不为空。

-spec take_smallest(Set1) -> {Element, Set2} when Set1 :: set(Element), Set2 :: set(Element).

返回 {Element, Set2},其中 ElementSet1 中最小的元素,而 Set2 是删除了 Element 的此集合。假设 Set1 不为空。

-spec to_list(Set) -> List when Set :: set(Element), List :: [Element].

Set 的元素作为列表返回。

-spec union(SetList) -> Set when SetList :: [set(Element), ...], Set :: set(Element).

返回集合列表的合并(并集)集合。

-spec union(Set1, Set2) -> Set3 when Set1 :: set(Element), Set2 :: set(Element), Set3 :: set(Element).

返回 Set1Set2 的合并(并集)集合。