bintrees 2.2.0

• Tree() -> 创建一个新空树；

• Tree(mapping) -> 从映射创建新树（只需要 items() 方法）

• Tree(seq) -> 从序列创建新树 [(k1, v1), (k2, v2), … (kn, vn)]

• __contains__(k) -> 如果 T 有键 k，则为 True，否则为 False，O(log(n))

• __delitem__(y) <==> del T[y], del[s:e], O(log(n))

• __getitem__(y) <==> T[y], T[s:e], O(log(n))

• __iter__() <==> iter(T)

• __len__() <==> len(T), O(1)

• __max__() <==> max(T)，获取 T 的最大项 (k,v)，O(log(n))

• __min__() <==> min(T)，获取 T 的最小项 (k,v)，O(log(n))

• __and__(other) <==> T & other，交集

• __or__(other) <==> T | other，并集

• __sub__(other) <==> T - other，差集

• __xor__(other) <==> T ^ other，对称差集

• __repr__() <==> repr(T)

• __setitem__(k, v) <==> T[k] = v，O(log(n))

• __copy__() -> 浅拷贝支持，copy.copy(T)

• __deepcopy__() -> 深拷贝支持，copy.deepcopy(T)

• clear() -> None，从 T 中移除所有项，O(n)

• copy() -> T 的浅拷贝，O(n*log(n))

• discard(k) -> None，从 T 中移除 k，如果存在，O(log(n))

• get(k[,d]) -> T[k] 如果 k 在 T 中，否则 d，O(log(n))

• is_empty() -> 如果 len(T) == 0，则为 True，O(1)

• items([reverse]) -> T 中 (k, v) 项的生成器，O(n)

• keys([reverse]) -> T 中键的生成器，O(n)

• values([reverse]) -> T 中值的生成器，O(n)

• pop(k[,d]) -> v，移除指定的键并返回相应的值，O(log(n))

• pop_item() -> (k, v)，移除并返回一些 (键，值) 对作为二元组，O(log(n)) (同义词 popitem() 存在)

• set_default(k[,d]) -> value，T.get(k, d)，如果 k 不在 T 中，则也设置 T[k]=d，O(log(n)) (同义词 setdefault() 存在)

• update(E) -> None。从字典/可迭代对象 E 更新 T，O(E*log(n))

• foreach(f, [order]) -> 访问树的所有节点（0 = ‘inorder’，-1 = ‘preorder’ 或 +1 = ‘postorder’），并对每个节点调用 f(k, v)，O(n)

• iter_items(s, e[, reverse]) -> T 中 s <= key < e 的 (k, v) 项的生成器，O(n)

• remove_items(keys) -> None，通过键移除项，O(n)

• item_slice(s, e[, reverse]) -> T 中 s <= key < e 的 (k, v) 项的生成器，O(n)，同义词为 iter_items(…)

• key_slice(s, e[, reverse]) -> T 中 s <= key < e 的键的生成器，O(n)

• value_slice(s, e[, reverse]) -> T 中 s <= key < e 的值的生成器，O(n)

• T[s:e] -> TreeSlice 对象，其键在 s <= key < e 的范围内，O(n)

• del T[s:e] -> 通过键切片移除项，对于 s <= key < e，O(n)

起始/结束参数

• 如果 's' 为 None 或 T[:e] TreeSlice/迭代器从 min_key() 的值开始；

• 如果 'e' 为 None 或 T[s:] TreeSlice/迭代器以 max_key() 的值结束；

• T[:] 是表示整个树的 TreeSlice；

常规切片语法 T[s:e:step] 的步长参数将被静默忽略。

TreeSlice 是一个带有范围检查的树包装器，不包含对对象的引用，删除相关树中的对象也将删除 TreeSlice 中的对象。

• TreeSlice[k] -> 获取键 k 的值，如果 k 不在 s:e 范围内，则引发 KeyError

• TreeSlice[s1:e1] -> TreeSlice 对象，其键在 s1 <= key < e1 的范围内

  • 新下限是 max(s, s1)

  • 新上限是 min(e, e1)

TreeSlice 方法

• items() -> T 中 (k, v) 项的生成器，O(n)

• keys() -> T 中键的生成器，O(n)

• values() -> T 中值的生成器，O(n)

• __iter__ <==> keys()

• __repr__ <==> repr(T)

• __contains__(key) -> 如果TreeSlice包含键k，则返回True，否则返回False，时间复杂度为O(log(n))

• prev_item(key) -> 获取(k, v)对，其中k是key的前驱，时间复杂度为O(log(n))

• prev_key(key) -> k，获取key的前驱，时间复杂度为O(log(n))

• succ_item(key) -> 获取(k, v)对作为2元组，其中k是key的后继，时间复杂度为O(log(n))

• succ_key(key) -> k，获取key的后继，时间复杂度为O(log(n))

• floor_item(key) -> 获取(k, v)对，其中k是小于或等于key的最大键，时间复杂度为O(log(n))

• floor_key(key) -> k，获取小于或等于key的最大键，时间复杂度为O(log(n))

• ceiling_item(key) -> 获取(k, v)对，其中k是大于或等于key的最小键，时间复杂度为O(log(n))

• ceiling_key(key) -> k，获取大于或等于key的最小键，时间复杂度为O(log(n))

• max_item() -> 获取T中最大的(key, value)对，时间复杂度为O(log(n))

• max_key() -> 获取T中最大的键，时间复杂度为O(log(n))

• min_item() -> 获取T中最小的(key, value)对，时间复杂度为O(log(n))

• min_key() -> 获取T中最小的键，时间复杂度为O(log(n))

• pop_min() -> (k, v)，移除键最小的项，时间复杂度为O(log(n))

• pop_max() -> (k, v)，移除键最大的项，时间复杂度为O(log(n))

• nlargest(i[,pop]) -> 获取i个最大的(k, v)项列表，时间复杂度为O(i*log(n))

• nsmallest(i[,pop]) -> 获取i个最小的(k, v)项列表，时间复杂度为O(i*log(n))

• intersection(t1, t2, …) -> 包含所有树中公共键的树

• union(t1, t2, …) -> 包含任意一个树中键的树

• difference(t1, t2, …) -> 包含T中的键但不包含t1, t2, …中的键的树

• symmetric_difference(t1) -> 包含T和t1中但不同时包含两者的键的树

• is_subset(S) -> 如果T中的每个元素都在S中，则返回True（同义词issubset()存在）

• is_superset(S) -> 如果S中的每个元素都在T中，则返回True（同义词issuperset()存在）

• is_disjoint(S) -> 如果T和S没有交集，则返回True（同义词isdisjoint()存在）

• from_keys(S[,v]) -> 从S中获取键并赋予值v的新树。（同义词fromkeys()存在）

• bintrees.has_fast_tree_support() -> 如果Cython扩展正在工作，则返回True，否则返回False（False = 使用纯Python实现）