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()`