binstree 다운로드 - binstree 소스 코드 다운로드

빈스트리

ES6용 이진 검색 트리

설명

TypeScript를 지원하는 이진 검색 트리 데이터 구조의 ES6 구현입니다.

이 문서를 더 많은 언어로 번역하는 방법에 대해 자세히 알아보려면 기여 지침을 방문하세요.

내용물

설명
설치하다
심층적으로
용법
API
개발
관련된
팀
특허

설치하다

방사

yarn add binstree

NPM

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

API

나무. `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 입니다. 순회된 노드이고 마지막 값은 순회된 노드에 저장된 value 에 해당하는 any 유형의 값입니다. 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>

트리에 순차 순회를 적용하고 순회된 각 전체 노드(null이 아닌 두 개의 하위 노드가 있는 노드)를 배열에 저장합니다. 배열은 순회가 끝나면 반환됩니다.

 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>

트리에 순차 순회를 적용하고 각 부분 노드(null이 아닌 하위 노드가 하나 있는 노드)를 배열에 저장합니다. 배열은 순회가 끝나면 반환됩니다.

 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

트리가 높이 균형을 이룬 경우, 즉 왼쪽 하위 트리가 균형을 이루고 오른쪽 하위 트리가 균형을 이루고 왼쪽 하위 트리와 오른쪽 하위 트리의 높이 차이가 1보다 크지 않은 경우 true 반환합니다. 그렇지 않은 경우에는 메서드가 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

노드가 전체 노드(null이 아닌 두 개의 하위 노드 포함)인지 여부를 결정하고 적절하게 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

노드가 내부 노드(null이 아닌 하위 노드가 하나 이상 있음)인지 여부를 결정하여 적절하게 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

노드가 왼쪽 부분 노드(null이 아닌 왼쪽 자식이 하나만 있음)인지 여부를 결정하고 적절하게 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

노드가 부분 노드(null이 아닌 하위 노드가 하나만 있음)인지 여부를 결정하여 적절하게 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

노드가 오른쪽 부분 노드(null이 아닌 오른쪽 하위 노드 하나만 가짐)인지 여부를 결정하여 적절하게 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]

첫 번째 요소는 노드의 key 에 해당하는 숫자이고 마지막 요소는 노드에 저장된 value 에 해당하는 모든 유형의 값인 순서쌍/2-튜플을 반환합니다.

 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
코드 린트 및 테스트 실행: npm test 또는 yarn test

팀

클라우스 시나니(@klaussinani)

특허

MIT

확장하다

binstree

빈스트리

ES6용 이진 검색 트리

설명

내용물

설치하다

방사

NPM

심층적으로

용법

API

나무. 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()`