binstree Unduh - pengunduhan kode sumber binstree

Binstree

Pohon pencarian biner untuk ES6

Keterangan

Implementasi ES6 dari struktur data pohon pencarian biner dengan dukungan TypeScript.

Kunjungi pedoman kontribusi untuk mempelajari lebih lanjut tentang cara menerjemahkan dokumen ini ke lebih banyak bahasa.

Isi

Keterangan
Memasang
Secara mendalam
Penggunaan
API
Perkembangan
Terkait
Tim
Lisensi

Memasang

Benang

yarn add binstree

NPM

npm install binstree

Secara mendalam

Pohon pencarian biner adalah struktur data pohon biner berakar, yang simpulnya berisi key unik & value terkait, dan menunjuk ke dua subpohon left dan right yang berbeda. Pohon tersebut memenuhi properti pencarian biner, sehingga kunci di setiap node lebih besar dari kunci mana pun yang disimpan di subpohon kiri, dan lebih kecil dari kunci apa pun yang disimpan di subpohon kanan. Sebagai hasil langsung dari prinsip ini, operasi pohon sangat diuntungkan, karena rata-rata setiap perbandingan kunci memungkinkan operasi melewati sekitar setengah dari pohon, sehingga setiap penyisipan, penghapusan, atau pencarian memerlukan waktu yang sebanding dengan logaritma jumlah node. disimpan di pohon.

Penggunaan

Binstree memperlihatkan API yang dapat dirantai, yang dapat digunakan melalui sintaksis sederhana dan minimal, memungkinkan Anda menggabungkan metode secara efektif.

Contoh penggunaan juga dapat ditemukan di direktori 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

pohon. `insert(key, value)`

Tipe Pengembalian: Tree

Mutasi pohon dengan menyisipkan node baru di lokasi yang sesuai.

`key`

Jenis: Number

Bisa berupa nomor apa saja yang sesuai dengan key node yang dibuat. Setiap node memiliki key uniknya sendiri.

`value`

Jenis: Any

Bisa berupa nilai apa pun yang akan disimpan di node yang dibuat.

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

const tree = new Tree ( ) ;

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

pohon. `root`

Jenis Pengembalian: Node | null

Mengembalikan simpul akar pohon. Jika pohon kosong, null dikembalikan.

 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 }

pohon. `isEmpty()`

Jenis Pengembalian: Boolean

Menentukan apakah pohon itu kosong, mengembalikan true atau false sebagaimana mestinya.

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

const tree = new Tree ( ) ;

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

pohon. `remove(key)`

Tipe Pengembalian: Tree

Mutasi pohon dengan menghapus simpul yang sesuai dengan argumen key .

`key`

Jenis: Number

Bisa berupa nomor apa saja yang sesuai dengan key dari node yang ada.

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

const tree = new Tree ( ) ;

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

pohon. `includes(key)`

Jenis Pengembalian: Boolean

Menentukan apakah pohon menyertakan simpul dengan key tertentu, mengembalikan true atau false sebagaimana mestinya.

`key`

Jenis: Number

key simpul untuk dicari.

 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

pohon. `search(key)`

Jenis Pengembalian: Node | null

Menentukan apakah pohon menyertakan simpul dengan key tertentu, mengembalikan simpul yang ditargetkan atau null sebagaimana mestinya.

`key`

Jenis: Number

key simpul untuk dicari.

 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 }

pohon. `min()`

Jenis Pengembalian: Node | null

Mengembalikan simpul paling kiri di pohon, sehingga simpul tersebut sesuai dengan key minimum.

 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 }

pohon. `max()`

Jenis Pengembalian: Node | null

Mengembalikan simpul paling kanan di pohon, sehingga simpul tersebut sesuai dengan key maksimum.

 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 }

pohon. `size()`

Jenis Pengembalian: Number

Mengembalikan jumlah total node yang berada di pohon.

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

const tree = new Tree ( ) ;

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

pohon. `height()`

Jenis Pengembalian: Number

Mengembalikan jarak maksimum setiap simpul daun dari akar. Jika pohonnya kosong -1 dikembalikan.

 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

pohon. `inOrder(fn)`

Tipe Pengembalian: Tree

Menerapkan traversal berurutan (traversal pertama kedalaman - LNR) ke pohon dan menjalankan fungsi fn yang disediakan pada setiap node yang dilintasi tanpa mengubah pohon itu sendiri.

`fn`

Jenis: Function

Berfungsi untuk dieksekusi pada setiap node.

 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

pohon. `preOrder(fn)`

Tipe Pengembalian: Tree

Menerapkan traversal praorder (traversal depth-first - NLR) ke pohon dan menjalankan fungsi fn yang disediakan pada setiap node yang dilintasi tanpa mengubah pohon itu sendiri.

`fn`

Jenis: Function

Berfungsi untuk dieksekusi pada setiap node.

 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

pohon. `postOrder(fn)`

Tipe Pengembalian: Tree

Menerapkan traversal pasca-urutan (traversal kedalaman-pertama - LRN) ke pohon dan menjalankan fungsi fn yang disediakan pada setiap node yang dilintasi tanpa mengubah pohon itu sendiri.

`fn`

Jenis: Function

Berfungsi untuk dieksekusi pada setiap node.

 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

pohon. `outOrder(fn)`

Tipe Pengembalian: Tree

Menerapkan traversal out-order (traversal depth-first - RNL) ke pohon dan menjalankan fungsi fn yang disediakan pada setiap node yang dilintasi tanpa mengubah pohon itu sendiri.

`fn`

Jenis: Function

Berfungsi untuk dieksekusi pada setiap node.

 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

pohon. `levelOrder(fn)`

Tipe Pengembalian: Tree

Menerapkan traversal tingkat-urutan (traversal luas-pertama) ke pohon dan menjalankan fungsi fn yang disediakan pada setiap node yang dilintasi tanpa mengubah pohon itu sendiri.

`fn`

Jenis: Function

Berfungsi untuk dieksekusi pada setiap node.

 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

pohon. `clear()`

Tipe Pengembalian: Tree

Mutasi pohon dengan menghapus semua node yang berada dan mengembalikannya dalam keadaan kosong.

 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

pohon. `toArray()`

Tipe Pengembalian: Array<Node>

Menerapkan traversal berurutan ke pohon dan menyimpan setiap node yang dilintasi dalam sebuah array. Array dikembalikan pada akhir traversal.

 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' }
// ]

pohon. `toPairs()`

Tipe Pengembalian: Array<[Number, Any]>

Menerapkan traversal berurutan ke pohon dan untuk setiap node yang dilintasi disimpan dalam n -tuple, di mana n ukuran pohon, sebuah pasangan terurut/2 tupel, dengan elemen pertama adalah number yang berkorespondensi dengan key dari pohon tersebut. node yang dilintasi, dan yang terakhir adalah nilai bertipe any , sesuai dengan value yang disimpan di node yang dilintasi. n -tuple dikembalikan pada akhir traversal.

 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'] ]

pohon. `leafNodes()`

Tipe Pengembalian: Array<Node>

Menerapkan penjelajahan berurutan ke pohon dan menyimpan setiap simpul daun yang dilintasi (simpul tanpa anak) dalam sebuah larik. Array dikembalikan pada akhir traversal.

 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' } 
// ]

pohon. `fullNodes()`

Tipe Pengembalian: Array<Node>

Menerapkan penjelajahan berurutan ke pohon dan menyimpan setiap simpul penuh yang dilintasi (simpul dengan dua turunan bukan nol) dalam sebuah larik. Array dikembalikan pada akhir traversal.

 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' } 
// ]

pohon. `partialNodes()`

Tipe Pengembalian: Array<Node>

Menerapkan traversal berurutan ke pohon dan menyimpan setiap simpul parsial (simpul dengan satu anak bukan nol) dalam sebuah larik. Array dikembalikan pada akhir traversal.

 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' }
// ]

pohon. `isBalanced()`

Jenis Pengembalian: Boolean

Mengembalikan true jika tinggi pohon seimbang, yang berarti bahwa subpohon kirinya seimbang, subpohon kanannya seimbang, dan perbedaan antara tinggi subpohon kiri dan subpohon kanan tidak lebih besar dari 1. Dalam jika tidak, metode akan mengembalikan 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

pohon. `isComplete()`

Jenis Pengembalian: Boolean

Metode ini mengembalikan true jika pohon tersebut adalah pohon pencarian biner lengkap, yang menyiratkan bahwa setiap level, kecuali mungkin yang terakhir, terisi penuh, dan semua node berada sejauh mungkin di kiri. Dalam kasus lain, metode ini mengembalikan nilai salah.

 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

pohon. `isFull()`

Jenis Pengembalian: Boolean

Metode ini mengembalikan true jika semua node yang berada di pohon adalah node daun atau node penuh. Dalam kasus lain (derajat simpul sama dengan 1) metode ini akan mengembalikan 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

pohon. `isPerfect()`

Jenis Pengembalian: Boolean

Metode ini mengembalikan true jika semua node internal yang berada di pohon adalah node penuh (derajat node sama dengan 2) dan semua node daun berada pada tingkat ketinggian yang sama. Dalam kasus lain (derajat simpul sama dengan 1 atau daun dan simpul penuh ditemukan pada tingkat ketinggian yang sama) metode ini akan mengembalikan 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

Juga tersedia, bersama dengan kelas Tree yang terekspos, adalah kelas Node , yang terutama berguna untuk tujuan pengujian, karena dapat digunakan untuk membandingkan node pohon. Kelas memiliki metode konstruktor biner, dengan parameter key dan value , masing-masing sesuai dengan kunci dan nilai yang disimpan dalam instance yang dibuat.

simpul. `key`

Jenis Pengembalian: Number

key yang sesuai dengan instance node.

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

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

simpul. `value`

Jenis Pengembalian: Any

Nilai yang terkandung dalam node.

 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 }

simpul. `left`

Jenis Pengembalian: Node | null

Subpohon kiri yang ditunjuk oleh node.

 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 }

simpul. `right`

Jenis Pengembalian: Node | null

Subpohon kanan yang ditunjuk oleh node.

 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 }

simpul. `children`

Tipe Pengembalian: Array<Node>

Mengembalikan larik yang menghubungi turunan dari instance tersebut, dengan anak kiri, jika ada, adalah elemen pertama larik, dan anak kanan, jika ada, adalah elemen terakhir larik.

 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 }
// ]

simpul. `degree`

Jenis Pengembalian: Number

Mengembalikan jumlah subpohon yang ditunjuk oleh node.

 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

simpul. `height()`

Jenis Pengembalian: Number

Mengembalikan jarak maksimum setiap simpul daun dari contoh simpul.

 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

simpul. `isFull()`

Jenis Pengembalian: Boolean

Menentukan apakah sebuah node merupakan node penuh (memiliki dua anak yang bukan null), mengembalikan true atau false sebagaimana mestinya.

 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

simpul. `isInternal()`

Jenis Pengembalian: Boolean

Menentukan apakah sebuah node merupakan node internal (memiliki setidaknya satu anak bukan nol), mengembalikan true atau false sebagaimana mestinya.

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

const tree = new Tree ( ) ;

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

simpul. `isLeaf()`

Jenis Pengembalian: Boolean

Menentukan apakah sebuah simpul adalah simpul daun (tidak memiliki anak), mengembalikan true atau false sebagaimana mestinya.

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

const tree = new Tree ( ) ;

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

simpul. `isLeftPartial()`

Jenis Pengembalian: Boolean

Menentukan apakah sebuah node merupakan node parsial kiri (hanya memiliki satu anak non-null yang tersisa), mengembalikan true atau false sebagaimana mestinya.

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

const tree = new Tree ( ) ;

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

simpul. `isPartial()`

Jenis Pengembalian: Boolean

Menentukan apakah sebuah node merupakan node parsial (hanya memiliki satu anak yang bukan nol), mengembalikan true atau false sebagaimana mestinya.

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

const tree = new Tree ( ) ;

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

simpul. `isRightPartial()`

Jenis Pengembalian: Boolean

Menentukan apakah sebuah simpul merupakan simpul parsial kanan (memiliki satu anak bukan nol yang benar), mengembalikan true atau false sebagaimana mestinya.

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

const tree = new Tree ( ) ;

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

simpul. `toPair()`

Jenis Pengembalian: [Number, Any]

Mengembalikan tupel pasangan terurut/2, dengan elemen pertama adalah angka yang berkorespondensi dengan key dari node, dan elemen terakhir adalah sebuah nilai, yang bisa berjenis apa pun, sesuai dengan value yang disimpan di dalam node.

 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']

Perkembangan

Untuk informasi lebih lanjut tentang cara berkontribusi pada proyek, silakan baca pedoman berkontribusi.

Fork repositori dan kloning ke mesin Anda
Arahkan ke fork lokal Anda: cd binstree
Instal dependensi proyek: npm install atau yarn install
Lint kode dan jalankan tes: npm test atau yarn test

Terkait

avlbinstree - Pohon pencarian biner AVL yang menyeimbangkan diri sendiri untuk ES6
binoheap - Tumpukan binomial untuk ES6
doublie - Daftar tertaut melingkar & linier ganda untuk ES6
dsforest - Hutan yang terpisah untuk ES6
kiu - Antrian FIFO untuk ES6
mheap - Tumpukan biner min & maks untuk ES6
prioqueue - Antrian prioritas untuk ES6
shtack - Tumpukan LIFO untuk ES6
singlie - Daftar tertaut melingkar & linier tunggal untuk ES6

Tim

Klaus Sinani (@klaussinani)

Lisensi

MIT

Memperluas

binstree

Binstree

Pohon pencarian biner untuk ES6

Keterangan

Isi

Memasang

Benang

NPM

Secara mendalam

Penggunaan

API

pohon. insert(key, value)

key

value

pohon. root

pohon. isEmpty()

pohon. remove(key)

key

pohon. includes(key)

key

pohon. search(key)

key

pohon. min()

pohon. max()

pohon. size()

pohon. height()

pohon. inOrder(fn)

fn

pohon. preOrder(fn)

fn

pohon. postOrder(fn)

fn

pohon. outOrder(fn)

fn

pohon. levelOrder(fn)

fn

pohon. clear()

pohon. toArray()

pohon. toPairs()

pohon. leafNodes()

pohon. fullNodes()

pohon. partialNodes()

pohon. isBalanced()

pohon. isComplete()

pohon. isFull()

pohon. isPerfect()

simpul. key

simpul. value

simpul. left

simpul. right

simpul. children

simpul. degree

simpul. height()

simpul. isFull()

simpul. isInternal()

simpul. isLeaf()

simpul. isLeftPartial()

simpul. isPartial()

simpul. isRightPartial()

simpul. toPair()

Perkembangan

Terkait

Tim

Lisensi

pohon. `insert(key, value)`

`key`

`value`

pohon. `root`

pohon. `isEmpty()`

pohon. `remove(key)`

`key`

pohon. `includes(key)`

`key`

pohon. `search(key)`

`key`

pohon. `min()`

pohon. `max()`

pohon. `size()`

pohon. `height()`

pohon. `inOrder(fn)`

`fn`

pohon. `preOrder(fn)`

`fn`

pohon. `postOrder(fn)`

`fn`

pohon. `outOrder(fn)`

`fn`

pohon. `levelOrder(fn)`

`fn`

pohon. `clear()`

pohon. `toArray()`

pohon. `toPairs()`

pohon. `leafNodes()`

pohon. `fullNodes()`

pohon. `partialNodes()`

pohon. `isBalanced()`

pohon. `isComplete()`

pohon. `isFull()`

pohon. `isPerfect()`

simpul. `key`

simpul. `value`

simpul. `left`

simpul. `right`

simpul. `children`

simpul. `degree`

simpul. `height()`

simpul. `isFull()`

simpul. `isInternal()`

simpul. `isLeaf()`

simpul. `isLeftPartial()`

simpul. `isPartial()`

simpul. `isRightPartial()`

simpul. `toPair()`