binstree下载 - binstree源码下载

宾斯特里

ES6 的二叉搜索树

描述

具有 TypeScript 支持的二叉搜索树数据结构的 ES6 实现。

请访问贡献指南，了解有关如何将此文档翻译成更多语言的更多信息。

内容

描述
安装
深入
用法
应用程序编程接口
发展
有关的
团队
执照

安装

纱

yarn add binstree

国家公共管理

npm install binstree

深入

二叉搜索树是一种有根二叉树数据结构，其节点包含唯一的key和关联value ，并指向两个不同的left树和right树。该树满足二分查找性质，因此每个节点中的关键字都大于左子树中存储的任何关键字，并且小于右子树中存储的任何关键字。作为这一原理的迫在眉睫的结果，树操作将受益匪浅，因为平均每次键比较允许操作跳过大约一半的树，因此每次插入、删除或查找所花费的时间与节点数量的对数成正比存储在树中。

用法

Binstree 公开了一个可链接的 API，可以通过简单且最少的语法来使用它，从而允许您有效地组合方法。

用法示例也可以在test目录中找到。

 'use strict' ;
const { Tree , Node } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;
//=> Tree { root: null }

tree . insert ( 10 , 'A' ) ;
// => Tree { root: Node { left: null, right: null, key: 10, value: 'A' } }

tree . root ;
//=> Node { left: null, right: null, key: 10, value: 'A' }

const node = new Node ( 10 , 'A' ) ;

tree . root . key === node . key ;
//=> true

tree . root . value === node . value ;
//=> true

tree . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) . root ;
//=> Node { left: [Node], right: [Node], key: 10, value: 'A' }

tree . root . left ;
//=> Node { left: null, right: null, key: 5, value: 'B' }

tree . root . right ;
//=> Node { left: null, right: null, key: 15, value: 'C' }

tree . insert ( 2 , 'D' ) . insert ( 7 , 'E' ) . insert ( 12 , 'F' ) . insert ( 20 , 'G' ) ;

tree . search ( 5 ) ;
//=> Node { key: 5, value: 'B',
//  left: Node { left: null, right: null, key: 2, value: 'D' },
//  right: Node { left: null, right: null, key: 7, value: 'E' } }

tree . search ( 15 ) ;
//=> Node { key: 15, value: 'C',
//  left: Node { left: null, right: null, key: 12, value: 'F' },
//  right: Node { left: null, right: null, key: 20, value: 'G' } }

tree . includes ( 12 ) ;
//=> true

tree . includes ( 100 ) ;
//=> false

tree . height ( ) ;
//=> 2

tree . isBalanced ( ) ;
//=> true

tree . remove ( 10 ) . root ;
//=> Node { key: 12, value: 'F',
//  left: Node { left: [Node], right: [Node], key: 5, value: 'B' },
//  right: Node { left: null, right: [Node], key: 15, value: 'C' } }

tree . isBalanced ( ) ;
//=> false

应用程序编程接口

树。 `insert(key, value)`

返回类型： Tree

通过在适当的位置插入新节点来改变树。

`key`

类型： Number

可以是与所创建节点的key对应的任何数字。每个节点都有自己唯一的key 。

`value`

类型： Any

可以是将存储在创建的节点中的任何值。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) ;
// => Tree { root: Node { key: 10, value: 'A', left: null, right: null } }

树。 `root`

返回类型： Node | null

返回树的根节点。如果树为空，则返回null 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) ;
// => Tree { root: Node { key: 10, value: 'A', left: null, right: null } }
tree . root ;
// => Node { key: 10, value: 'A', left: null, right: null }

树。 `isEmpty()`

返回类型： Boolean

确定树是否为空，根据情况返回true或false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) ;
tree . isEmpty ( ) ;
// => false

树。 `remove(key)`

返回类型： Tree

通过删除与key参数对应的节点来改变树。

`key`

类型： Number

可以是与现有节点的key对应的任何数字。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) ;
tree . remove ( 10 ) ;
//=> Tree { root: null }

树。 `includes(key)`

返回类型： Boolean

确定树是否包含具有特定key节点，根据需要返回true或false 。

`key`

类型： Number

要搜索的节点key 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) ;
tree . includes ( 10 ) ;
// => true
tree . includes ( 25 ) ;
// => false
tree . includes ( 5 ) ;
// => true

树。 `search(key)`

返回类型： Node | null

确定树中是否包含具有特定key节点，根据情况返回目标节点或null 。

`key`

类型： Number

要搜索的节点key 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) ;
tree . search ( 10 ) ;
// => Node { key: 10, value: 'A', left: [Node], right: null }
tree . search ( 25 ) ;
// => null
tree . search ( 5 ) ;
// => Node { key: 5, value: 'B', left: null, right: null }

树。 `min()`

返回类型： Node | null

返回树中最左边的节点，即对应于最小key节点。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 0 , 'C' ) ;
tree . min ( ) ;
// => Node { key: 0, value: 'C', left: null, right: null }

树。 `max()`

返回类型： Node | null

返回树中最右边的节点，即对应于最大key节点。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 15 , 'B' ) . insert ( 25 , 'C' ) ;
tree . max ( ) ;
// => Node { key: 25, value: 'C', left: null, right: null }

树。 `size()`

返回类型： Number

返回树中的节点总数。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 15 , 'B' ) . insert ( 25 , 'C' ) ;
tree . size ( ) ;
// => 3

树。 `height()`

返回类型： Number

返回任何叶节点距根的最大距离。如果树为空，则返回-1 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) ;
tree . height ( ) ;
// => 0
tree . insert ( 15 , 'B' ) . insert ( 25 , 'C' ) . insert ( 35 , 'D' ) ;
tree . height ( ) ;
//=> 3

树。 `inOrder(fn)`

返回类型： Tree

对树应用中序遍历（深度优先遍历 - LNR），并在每个遍历的节点上执行提供的fn函数，而不改变树本身。

`fn`

类型： Function

在每个节点上执行的函数。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . inOrder ( node => console . log ( node . key ) ) ;
// => 5
// 10
// 15

树。 `preOrder(fn)`

返回类型： Tree

对树应用前序遍历（深度优先遍历 - NLR），并在每个遍历的节点上执行提供的fn函数，而不改变树本身。

`fn`

类型： Function

在每个节点上执行的函数。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . preOrder ( node => console . log ( node . key ) ) ;
// => 10
// 5
// 15

树。 `postOrder(fn)`

返回类型： Tree

对树应用后序遍历（深度优先遍历 - LRN），并在每个遍历的节点上执行提供的fn函数，而不改变树本身。

`fn`

类型： Function

在每个节点上执行的函数。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . postOrder ( node => console . log ( node . key ) ) ;
// => 5
// 15
// 10

树。 `outOrder(fn)`

返回类型： Tree

对树应用无序遍历（深度优先遍历 - RNL），并在每个遍历的节点上执行提供的fn函数，而不改变树本身。

`fn`

类型： Function

在每个节点上执行的函数。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . outOrder ( node => console . log ( node . key ) ) ;
// => 15
// 10
// 5

树。 `levelOrder(fn)`

返回类型： Tree

对树应用层序遍历（广度优先遍历），并在每个遍历的节点上执行提供的fn函数，而不改变树本身。

`fn`

类型： Function

在每个节点上执行的函数。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . levelOrder ( node => console . log ( node . key ) ) ;
// => 10
// 5
// 15

树。 `clear()`

返回类型： Tree

通过删除所有驻留节点来改变树并将其返回为空。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
//=> Tree { root: Node { left: [Node], right: [Node], key: 3, value: 'A' } }
tree . size ( ) ;
//=> 3
tree . clear ( ) ;
//=> Tree { root: null } }
tree . size ( ) ;
//=> 0

树。 `toArray()`

返回类型： Array<Node>

对树进行中序遍历，并将每个遍历到的节点存储在数组中。遍历结束时返回该数组。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) . insert ( 3 , 'D' ) . insert ( 20 , 'F' ) ;
tree . toArray ( ) ;
//=> [ 
//  Node { left: null, right: null, key: 3, value: 'D' },
//  Node { left: [Node], right: null, key: 5, value: 'B' },
//  Node { left: [Node], right: [Node], key: 10, value: 'A' },
//  Node { left: null, right: [Node], key: 15, value: 'C' },
//  Node { left: null, right: null, key: 20, value: 'F' }
// ]

树。 `toPairs()`

返回类型： Array<[Number, Any]>

对树应用中序遍历，并将每个遍历的节点存储在一个n元组中，其中n树的大小，一个有序对/2 元组，其中第一个元素是对应于该树的key的number遍历到的节点，最后一个是any类型的值，对应遍历到的节点中存储的value 。遍历结束时返回n元组。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) . insert ( 3 , 'D' ) . insert ( 20 , 'F' ) ;
tree . toPairs ( ) ;
//=> [ [3, 'D'], [5, 'B'], [10, 'A'], [15, 'C'], [20, 'F'] ]

树。 `leafNodes()`

返回类型： Array<Node>

对树进行中序遍历，并将每个遍历的叶节点（没有子节点的节点）存储在数组中。遍历结束时返回该数组。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . leafNodes ( ) ;
//=> [ 
//  Node { left: null, right: null, key: 5, value: 'B' },
//  Node { left: null, right: null, key: 15, value: 'C' } 
// ]

树。 `fullNodes()`

返回类型： Array<Node>

对树应用中序遍历，并将每个遍历的完整节点（具有两个非空子节点的节点）存储在数组中。遍历结束时返回该数组。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . fullNodes ( ) ;
//=> [ 
//  Node { left: [Node], right: [Node], key: 10, value: 'A' } 
// ]

树。 `partialNodes()`

返回类型： Array<Node>

对树应用中序遍历并将每个部分节点（具有一个非空子节点的节点）存储在数组中。遍历结束时返回该数组。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) . insert ( 20 , 'D' ) . insert ( 3 , 'E' ) ;
tree . partialNodes ( ) ;
//=> [ 
//  Node { left: [Node], right: null, key: 5, value: 'B' },
//  Node { left: null, right: [Node], key: 15, value: 'C' }
// ]

树。 `isBalanced()`

返回类型： Boolean

如果树是高度平衡的，则返回true ，这意味着它的左子树是平衡的，右子树是平衡的，并且左子树和右子树的高度差不大于 1。在任何其他情况下，该方法都会返回false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . isBalanced ( ) ;
//=> true
tree . insert ( 20 , 'D' ) . insert ( 30 , 'E' ) ;
tree . isBalanced ( ) ;
//=> false

树。 `isComplete()`

返回类型： Boolean

如果树是完全二叉搜索树，则该方法返回true ，这意味着每个级别（可能除了最后一个级别）都已完全填充，并且所有节点都尽可能位于左侧。在任何其他情况下，该方法都会返回 false。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . isComplete ( ) ;
//=> true
tree . insert ( 3 , 'D' ) ;
tree . isComplete ( ) ;
//=> true
tree . insert ( 20 , 'E' ) ;
tree . isComplete ( ) ;
//=> false

树。 `isFull()`

返回类型： Boolean

如果树中的所有节点都是叶节点或完整节点，则该方法返回true 。在任何其他情况下（节点度数等于 1），该方法都会返回false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . isFull ( ) ;
//=> true
tree . insert ( 8 , 'D' ) ;
tree . isFull ( ) ;
//=> false

树。 `isPerfect()`

返回类型： Boolean

如果树中的所有内部节点都是完整节点（节点度等于 2）并且所有叶节点处于相同的高度级别，则该方法返回true 。在任何其他情况下（节点度数等于 1 或在同一高度级别上找到叶节点和完整节点），该方法将返回false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) ;
tree . isPerfect ( ) ;
//=> true
tree . insert ( 3 , 'D' ) . insert ( 7 , 'E' ) . insert ( 12 , 'F' ) . insert ( 20 , 'G' ) ;
tree . isPerfect ( ) ;
//=> true
tree . insert ( 1 , 'H' ) ;
tree . isPerfect ( ) ;
//=> false

除了Tree公开类之外，还可以使用Node类，主要用于测试目的，因为它可用于比较树节点。该类有一个二进制构造函数方法，带有一个key和一个value参数，分别对应于创建的实例中存储的键和值。

节点。 `key`

返回类型： Number

节点实例对应的key 。

 const { Node } = require ( 'binstree' ) ;

const node = new Node ( 10 , 'A' ) ;
// => { key:10, value: 'A', left: null, right: null }
node . key ;
//=> 10

节点。 `value`

返回类型： Any

节点包含的值。

 const { Node } = require ( 'binstree' ) ;

const node = new Node ( 10 , 'A' ) ;

// => { key: 10, value: 'A', left: null, right: null }
node . value ;
//=> 'A'
node . value = 'B'
// => { key: 10, value: 'B', left: null, right: null }

节点。 `left`

返回类型： Node | null

节点指向的左子树。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root ;
// => { key: 10, value: 'A', left: null, right: null }
tree . root . left ;
//=> null
tree . insert ( 5 , 'B' ) . root ;
// => { key: 10, value: 'A', left: { key: 5, value: 'B', left: null, right: null } , right: null }
tree . root . left ;
//=> { key: 5, value: 'B', left: null, right: null }

节点。 `right`

返回类型： Node | null

节点指向的右子树。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root ;
// => { key: 10, value: 'A', left: null, right: null }
tree . root . right ;
//=> null
tree . insert ( 15 , 'B' ) . root ;
// => { key: 10, value: 'A', left: null , right: { key: 15, value: 'B', left: null, right: null } }
tree . root . right ;
//=> { key: 15, value: 'B', left: null, right: null }

节点。 `children`

返回类型： Array<Node>

返回联系实例子级的数组，其中左子级（如果存在）是数组的第一个元素，右子级（如果存在）是数组的最后一个元素。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . children ;
//=> []
tree . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) . root . children ;
// => [
//  { key: 5, value: 'B', left: null , right: null }, 
//  { key: 15, value: 'C', left: null, right: null }
// ]

节点。 `degree`

返回类型： Number

返回节点指向的子树的数量。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . degree ;
//=> 0
tree . insert ( 5 , 'B' ) . root . degree ;
//=> 1
tree . insert ( 15 , 'C' ) . root . degree ;
//=> 2

节点。 `height()`

返回类型： Number

返回任何叶节点距节点实例的最大距离。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . insert ( 15 , 'B' ) . insert ( 25 , 'C' ) . insert ( 35 , 'D' ) ;
tree . root . height ( ) ;
//=> 3
tree . root . right . height ( ) ;
//=> 2

节点。 `isFull()`

返回类型： Boolean

确定节点是否为完整节点（有两个非空子节点），根据需要返回true或false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . isFull ( ) ;
//=> false
tree . insert ( 5 , 'B' ) . insert ( 15 , 'C' ) . root . isFull ( ) ;
//=> true

节点。 `isInternal()`

返回类型： Boolean

确定节点是否为内部节点（至少有一个非空子节点），根据情况返回true或false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . isInternal ( ) ;
//=> false
tree . insert ( 5 , 'B' ) . root . isInternal ( ) ;
//=> true

节点。 `isLeaf()`

返回类型： Boolean

确定节点是否为叶节点（没有子节点），根据需要返回true或false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . isLeaf ( ) ;
//=> true
tree . insert ( 5 , 'B' ) . root . isLeaf ( ) ;
//=> false

节点。 `isLeftPartial()`

返回类型： Boolean

确定节点是否为左部分节点（只有一个左非空子节点），根据情况返回true或false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . isLeftPartial ( ) ;
//=> false
tree . insert ( 5 , 'B' ) . root . isLeftPartial ( ) ;
//=> true

节点。 `isPartial()`

返回类型： Boolean

确定节点是否为部分节点（只有一个非空子节点），根据情况返回true或false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . isPartial ( ) ;
//=> false
tree . insert ( 15 , 'B' ) . root . isPartial ( ) ;
//=> true

节点。 `isRightPartial()`

返回类型： Boolean

确定节点是否为右部分节点（只有一个右非空子节点），根据情况返回true或false 。

 const { Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;

tree . insert ( 10 , 'A' ) . root . isRightPartial ( ) ;
//=> false
tree . insert ( 15 , 'B' ) . root . isRightPartial ( ) ;
//=> true

节点。 `toPair()`

返回类型： [Number, Any]

返回一个有序对/2元组，其中第一个元素是对应于节点的key的数字，最后一个元素是一个值，可以是任何类型，对应于存储在节点中的value 。

 const { Node , Tree } = require ( 'binstree' ) ;

const tree = new Tree ( ) ;
const node = new Node ( 5 , 'B' ) ;

node . toPair ( ) ;
//=> [5, 'B']
tree . insert ( 10 , 'A' ) . root . toPair ( ) ;
//=> [10, 'A']

发展

有关如何为该项目做出贡献的更多信息，请阅读贡献指南。

分叉存储库并将其克隆到您的计算机
导航到本地分支： cd binstree
安装项目依赖： npm install或yarn install
Lint 代码并运行测试： npm test或yarn test

有关的

avlbinstree - ES6 的 AVL 自平衡二叉搜索树
binoheap - ES6 的二项式堆
doublie - ES6 的双向循环和线性链表
dsforest - ES6 的不相交集森林
kiu - ES6 的 FIFO 队列
mheap - ES6 的二进制最小和最大堆
prioqueue - ES6 的优先级队列
shtack - ES6 的 LIFO 堆栈
singlelie - ES6 的单循环和线性链表

团队

克劳斯·西纳尼 (@klaussinani)

执照

麻省理工学院

展开

binstree

宾斯特里

ES6 的二叉搜索树

描述

内容

安装

纱

国家公共管理

深入

用法

应用程序编程接口

树。 insert(key, value)

key

value

树。 root

树。 isEmpty()

树。 remove(key)

key

树。 includes(key)

key

树。 search(key)

key

树。 min()

树。 max()

树。 size()

树。 height()

树。 inOrder(fn)

fn

树。 preOrder(fn)

fn

树。 postOrder(fn)

fn

树。 outOrder(fn)

fn

树。 levelOrder(fn)

fn

树。 clear()

树。 toArray()

树。 toPairs()

树。 leafNodes()

树。 fullNodes()

树。 partialNodes()

树。 isBalanced()

树。 isComplete()

树。 isFull()

树。 isPerfect()

节点。 key

节点。 value

节点。 left

节点。 right

节点。 children

节点。 degree

节点。 height()

节点。 isFull()

节点。 isInternal()

节点。 isLeaf()

节点。 isLeftPartial()

节点。 isPartial()

节点。 isRightPartial()

节点。 toPair()

发展

有关的

团队

执照

树。 `insert(key, value)`

`key`

`value`

树。 `root`

树。 `isEmpty()`

树。 `remove(key)`

`key`

树。 `includes(key)`

`key`

树。 `search(key)`

`key`

树。 `min()`

树。 `max()`

树。 `size()`

树。 `height()`

树。 `inOrder(fn)`

`fn`

树。 `preOrder(fn)`

`fn`

树。 `postOrder(fn)`

`fn`

树。 `outOrder(fn)`

`fn`

树。 `levelOrder(fn)`

`fn`

树。 `clear()`

树。 `toArray()`

树。 `toPairs()`

树。 `leafNodes()`

树。 `fullNodes()`

树。 `partialNodes()`

树。 `isBalanced()`

树。 `isComplete()`

树。 `isFull()`

树。 `isPerfect()`

节点。 `key`

节点。 `value`

节点。 `left`

节点。 `right`

节点。 `children`

节点。 `degree`

节点。 `height()`

节点。 `isFull()`

节点。 `isInternal()`

节点。 `isLeaf()`

节点。 `isLeftPartial()`

节点。 `isPartial()`

节点。 `isRightPartial()`

节点。 `toPair()`