@cute-dw/core
Version:
This TypeScript library is the main part of a more powerfull package designed for the fast WEB software development. The cornerstone of the library is the **DataStore** class, which might be useful when you need a full control of the data, but do not need
200 lines • 21.3 kB
JavaScript
import { Comparator } from "../../util/Comparator";
import { BinaryTreeNode } from "./BinaryTreeNode";
/**
* In computer science, binary search trees (BST), sometimes called ordered or sorted binary trees,
* are a particular type of container: data structures that store "items" (such as numbers, names etc.)
* in memory. They allow fast lookup, addition and removal of items, and can be used to implement
* either dynamic sets of items, or lookup tables that allow finding an item by its key
* (e.g., finding the phone number of a person by name).
*/
export class BinarySearchTree {
constructor(comparator) {
this.root = null;
this.keyComparator = comparator ?? Comparator.getInstance();
}
clear() {
this.forEach((value, key) => { this.remove(key); });
}
count() {
let nCount = 0;
this.forEach(() => nCount++);
return nCount;
}
height() {
if (this.root) {
return this.root.height;
}
return 0;
}
/**
* Test the tree for empness
* @returns _true_ if the tree doesn't have child nodes, else _false_
*/
isEmpty() {
return (this.root == null);
}
/**
* Inserts a new element to the tree
* @param {K} key
* @param {*} value
* @returns {BinaryTreeNode}
*/
add(key, value) {
if (this.root) {
return this.root.add(key, value);
}
this.root = new BinaryTreeNode(key, value, this.keyComparator);
return this.root;
}
/**
* @param {*} key
* @return {boolean}
*/
contains(key) {
if (this.root)
return this.root.contains(key);
return false;
}
/**
*
* @param key
* @returns
*/
get(key) {
if (this.root) {
const node = this.root.findNode(key);
if (node) {
return node.value;
}
}
return undefined;
}
/**
* @param {K} key
* @returns {Element|undefined}
*/
remove(key) {
if (this.root) {
const removedNode = this.root.remove(key);
if (removedNode) {
return removedNode.value;
}
}
return undefined;
}
/**
* @return {string}
*/
toString() {
if (this.root)
return this.root.toString();
return "";
}
/**
* Executes a `callBack` function for each entry in this dictionary
* @param callBack Function to call on each tree item
* @param thisArg An object to which the `this` keyword can refer in the `callBack` function. If `thisArg` is omitted, undefined is used as the `this` value
*/
forEach(callBack, thisArg) {
if (this.root) {
this.root.traverse().forEach(node => callBack(node.value, node.key, node), thisArg);
}
}
/**
* Gets an array of the children keys for the specified `key`
* @param key
* @returns
*/
childrenKeys(key) {
let keys = [];
const keyNode = this.root?.findNode(key);
if (keyNode) {
keyNode.traverse("PreOrder!").forEach(node => keys.push(node.key), this);
}
return keys.slice(1);
}
/**
* Gets an array of the parent keys for the specified `key`
* @param key
* @returns
*/
parentKeys(key) {
let keys = [];
const keyNode = this.root?.findNode(key);
if (keyNode) {
/*
let it = keyNode.traverseUpIterator();
let res: IteratorResult<BinaryTreeNode<K,V>>;
res = it.next();
while (!res.done) {
keys.push(res.value.key);
res = it.next();
}
*/
for (let node of keyNode.traverseUpIterator()) {
keys.push(node.key);
}
}
return keys.reverse();
}
/** Returns the first (lowest) key currently in this map */
firstKey() {
if (this.root) {
return this.root.findMin().key;
}
return undefined;
}
/** Returns the last (highest) key currently in this map */
lastKey() {
if (this.root) {
return this.root.findMax().key;
}
return undefined;
}
keySet() {
let set = new Set();
this.forEach((value, key) => set.add(key));
return set;
}
keys() {
if (this.root) {
return this.root.traverse().map(node => node.key);
}
return [];
}
values() {
if (this.root) {
return this.root.traverse().map(node => node.value);
}
return [];
}
*[Symbol.iterator]() {
if (this.root) {
yield* this.root.traverseDownIterator();
}
}
print(parentNode = null, indent = 0) {
parentNode = parentNode ?? this.root;
if (parentNode) {
let height;
let output = parentNode.key + "\r\n";
if (parentNode.left) {
height = parentNode.left.height;
output += "LEFT\r\n";
for (let node of parentNode.left.traverseDownIterator("PreOrder!")) {
output += "\t".repeat(height - node.height - 1 + node.parent.direction + node.direction) + node.key + (node.direction == 1 ? "R" : "L") + "\r\n";
}
}
if (parentNode.right) {
height = parentNode.right.height;
output += "RIGHT\r\n";
for (let node of parentNode.right.traverseDownIterator("PreOrder!")) {
output += "\t".repeat(height - node.height - 1 + node.parent.direction + node.direction) + node.key + (node.direction == 1 ? "R" : "L") + "\r\n";
}
}
return output;
}
return "";
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BinarySearchTree.js","sourceRoot":"","sources":["../../../../../../projects/cute-core/src/lib/collections/tree/BinarySearchTree.ts"],"names":[],"mappings":"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","sourcesContent":["import { Comparator } from \"../../util/Comparator\";\r\nimport { Element } from \"../Collection\";\r\nimport { BinaryTreeNode } from \"./BinaryTreeNode\";\r\n\r\n/**\r\n * In computer science, binary search trees (BST), sometimes called ordered or sorted binary trees,\r\n * are a particular type of container: data structures that store \"items\" (such as numbers, names etc.)\r\n * in memory. They allow fast lookup, addition and removal of items, and can be used to implement\r\n * either dynamic sets of items, or lookup tables that allow finding an item by its key\r\n * (e.g., finding the phone number of a person by name).\r\n */\r\nexport class BinarySearchTree<K, V=K> {\r\n  protected root: BinaryTreeNode<K, V> | null = null;\r\n  readonly keyComparator: Comparator<K>;\r\n\r\n  constructor(comparator?: Comparator<K>) {\r\n    this.keyComparator = comparator ?? Comparator.getInstance();\r\n  }\r\n\r\n  clear(): void {\r\n    this.forEach((value, key) => { this.remove(key) });\r\n  }\r\n\r\n  count(): number {\r\n    let nCount = 0;\r\n    this.forEach(()=>nCount++);\r\n    return nCount;\r\n  }\r\n\r\n  height(): number {\r\n    if (this.root) {\r\n      return this.root.height;\r\n    }\r\n    return 0;\r\n  }\r\n\r\n  /**\r\n   * Test the tree for empness\r\n   * @returns _true_ if the tree doesn't have child nodes, else _false_\r\n   */\r\n  isEmpty(): boolean {\r\n    return (this.root == null);\r\n  }\r\n  /**\r\n   * Inserts a new element to the tree\r\n   * @param {K} key\r\n   * @param {*} value\r\n   * @returns {BinaryTreeNode}\r\n   */\r\n  add(key: K, value: Element<V>): BinaryTreeNode<K, V> {\r\n    if (this.root) {\r\n      return this.root.add(key, value);\r\n    }\r\n    this.root = new BinaryTreeNode<K, V>(key, value, this.keyComparator);\r\n    return this.root;\r\n  }\r\n  /**\r\n   * @param {*} key\r\n   * @return {boolean}\r\n   */\r\n  contains(key: K): boolean {\r\n    if (this.root)\r\n      return this.root.contains(key);\r\n    return false;\r\n  }\r\n  /**\r\n   *\r\n   * @param key\r\n   * @returns\r\n   */\r\n  get(key: K): Element<V> | undefined {\r\n    if (this.root) {\r\n      const node = this.root.findNode(key);\r\n      if (node) {\r\n        return node.value;\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n  /**\r\n   * @param {K} key\r\n   * @returns {Element|undefined}\r\n   */\r\n  remove(key: K): Element<V> | undefined {\r\n    if (this.root) {\r\n      const removedNode = this.root.remove(key);\r\n      if (removedNode) {\r\n        return removedNode.value;\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n  /**\r\n   * @return {string}\r\n   */\r\n  toString(): string {\r\n    if (this.root)\r\n      return this.root.toString();\r\n    return \"\";\r\n  }\r\n  /**\r\n   * Executes a `callBack` function for each entry in this dictionary\r\n   * @param callBack  Function to call on each tree item\r\n   * @param thisArg   An object to which the `this` keyword can refer in the `callBack` function. If `thisArg` is omitted, undefined is used as the `this` value\r\n   */\r\n  forEach(callBack: (value: Element<V>, key: K, node: BinaryTreeNode<K, V>) => void, thisArg?: any): void {\r\n    if (this.root) {\r\n      this.root.traverse().forEach(node => callBack(node.value, node.key, node), thisArg);\r\n    }\r\n  }\r\n  /**\r\n   * Gets an array of the children keys for the specified `key`\r\n   * @param key\r\n   * @returns\r\n   */\r\n  childrenKeys(key: K): Array<K> {\r\n    let keys: K[] = [];\r\n    const keyNode = this.root?.findNode(key);\r\n    if (keyNode) {\r\n      keyNode.traverse(\"PreOrder!\").forEach(node => keys.push(node.key), this);\r\n    }\r\n    return keys.slice(1);\r\n  }\r\n  /**\r\n   * Gets an array of the parent keys for the specified `key`\r\n   * @param key\r\n   * @returns\r\n   */\r\n  parentKeys(key: K): Array<K> {\r\n    let keys: K[] = [];\r\n    const keyNode = this.root?.findNode(key);\r\n    if (keyNode) {\r\n      /*\r\n      let it = keyNode.traverseUpIterator();\r\n      let res: IteratorResult<BinaryTreeNode<K,V>>;\r\n      res = it.next();\r\n      while (!res.done) {\r\n        keys.push(res.value.key);\r\n        res = it.next();\r\n      }\r\n      */\r\n      for (let node of keyNode.traverseUpIterator()) {\r\n        keys.push(node.key);\r\n      }\r\n    }\r\n    return keys.reverse();\r\n  }\r\n  /** Returns the first (lowest) key currently in this map */\r\n  firstKey(): K | undefined {\r\n    if (this.root) {\r\n      return this.root.findMin().key;\r\n    }\r\n    return undefined;\r\n  }\r\n  /** Returns the last (highest) key currently in this map */\r\n  lastKey(): K | undefined {\r\n    if (this.root) {\r\n      return this.root.findMax().key;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  keySet(): Set<K> {\r\n    let set = new Set<K>();\r\n    this.forEach((value, key) => set.add(key));\r\n    return set;\r\n  }\r\n\r\n  keys(): Array<K> {\r\n    if (this.root) {\r\n      return this.root.traverse().map(node => node.key);\r\n    }\r\n    return [];\r\n  }\r\n\r\n  values(): Array<Element<V>> {\r\n    if (this.root) {\r\n      return this.root.traverse().map(node => node.value);\r\n    }\r\n    return [];\r\n  }\r\n\r\n  *[Symbol.iterator](): IterableIterator<BinaryTreeNode<K, V>> {\r\n    if (this.root) {\r\n      yield* this.root.traverseDownIterator();\r\n    }\r\n  }\r\n\r\n  print(parentNode: BinaryTreeNode<K, V> | null = null, indent: number = 0): string {\r\n    parentNode = parentNode ?? this.root;\r\n    if (parentNode) {\r\n      let height\r\n      let output = parentNode.key+\"\\r\\n\";\r\n      if (parentNode.left) {\r\n        height = parentNode.left.height;\r\n        output += \"LEFT\\r\\n\";\r\n        for (let node of parentNode.left.traverseDownIterator(\"PreOrder!\")) {\r\n          output += \"\\t\".repeat(height - node.height -1+ node.parent!.direction + node.direction) + node.key + (node.direction==1?\"R\":\"L\") + \"\\r\\n\";\r\n        }\r\n      }\r\n      if (parentNode.right) {\r\n        height = parentNode.right.height;\r\n        output += \"RIGHT\\r\\n\";\r\n        for (let node of parentNode.right.traverseDownIterator(\"PreOrder!\")) {\r\n          output += \"\\t\".repeat(height - node.height -1+ node.parent!.direction +node.direction) + node.key + (node.direction==1?\"R\":\"L\") + \"\\r\\n\";\r\n        }\r\n      }\r\n      return output;\r\n    }\r\n    return \"\";\r\n  }\r\n\r\n}\r\n"]}