@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
389 lines • 42.2 kB
JavaScript
import { Comparator } from "../../util/Comparator";
export class BinaryTreeNode {
constructor(key, value, comparator) {
this.left = null;
this.right = null;
this.parent = null;
this.value = null;
this.data = new Map();
this.nodeCompare = Comparator.compare;
this.value = value === undefined ? null : value;
this.key = key;
this.keyComparator = comparator ?? Comparator.getInstance();
}
/**
* @param {BinaryTreeNode} sourceNode
* @param {BinaryTreeNode} targetNode
* @static
*/
static copyNode(sourceNode, targetNode) {
targetNode.key = sourceNode.key;
targetNode.setValue(sourceNode.value);
targetNode.setLeft(sourceNode.left);
targetNode.setRight(sourceNode.right);
}
get height() {
return Math.max(this.leftHeight, this.rightHeight);
}
get leftHeight() {
if (!this.left)
return 0;
return this.left.height + 1;
}
get rightHeight() {
if (!this.right)
return 0;
return this.right.height + 1;
}
get balanceFactor() {
return this.leftHeight - this.rightHeight;
}
/**
* Get current node's sibling node if exists
* @returns {BinaryTreeNode}
*/
get sibling() {
// Check if current node has parent.
if (!this.parent) {
return undefined;
}
// So for now we know that current node has a parent and this
// parent has at least one children. Let's find out who is the brother.
if (this.nodeCompare(this, this.parent.left) == 0) {
// Right one is a sibling (if exists)
return this.parent.right ?? undefined;
}
// Left one is a sibling (if exists)
return this.parent.left ?? undefined;
}
/**
* Get parent's sibling if it exists.
* @returns {BinaryTreeNode}
*/
get uncle() {
// Check if current node has parent.
if (!this.parent) {
return undefined;
}
// Check if current node has grand-parent.
if (!this.parent.parent) {
return undefined;
}
// Check if grand-parent has two children.
if (!this.parent.parent.left || !this.parent.parent.right) {
return undefined;
}
// So for now we know that current node has grand-parent and this
// grand-parent has two children. Let's find out who is the uncle.
if (this.nodeCompare(this.parent, this.parent.parent.left) == 0) {
// Right one is an uncle.
return this.parent.parent.right;
}
// Left one is an uncle.
return this.parent.parent.left;
}
/**
* Gets the child direction of the current node relative to the parent node
* @returns `0` - if the node is the _left_ child, `1` - if the node is the _right_ child, `NaN` - node hasn't the parent node
*/
get direction() {
if (this.parent) {
if (this.parent.left == this) {
return 0;
}
return 1;
}
return NaN;
}
/**
* @param {*} value
* @returns {boolean}
*/
setValue(value) {
if (value === undefined)
return false;
this.value = value;
return true;
}
/**
* Sets a node as a left child node
* @param {BinaryTreeNode} node A new node to attach
* @returns {this} `this`
*/
setLeft(node) {
// Reset parent for left node since it is going to be detached.
if (this.left) {
this.left.parent = null;
}
// Attach new node to the left.
this.left = node;
// Make current node to be a parent for new left one.
if (this.left) {
this.left.parent = this;
}
return this;
}
/**
* Sets a node as a right child node
* @param {BinaryTreeNode} node A new node to attach
* @returns `this`
*/
setRight(node) {
// Reset parent for right node since it is going to be detached.
if (this.right) {
this.right.parent = null;
}
// Attach new node to the right.
this.right = node;
// Make current node to be a parent for new right one.
if (this.right) {
this.right.parent = this;
}
return this;
}
/**
* Removes a specified node if it was attached to this node as a child
* @param {BinaryTreeNode} nodeToRemove A node to remove if it is a child node
* @returns {boolean} _true_ if a node is a child node and it was removed successfully, else _false_
*/
removeChild(nodeToRemove) {
if (this.left && this.nodeCompare(this.left, nodeToRemove) == 0) {
this.left = null;
return true;
}
if (this.right && this.nodeCompare(this.right, nodeToRemove) == 0) {
this.right = null;
return true;
}
return false;
}
/**
* Replaces a child node
* @param {BinaryTreeNode} nodeToReplace
* @param {BinaryTreeNode} replacementNode
* @returns {boolean}
*/
replaceChild(nodeToReplace, replacementNode) {
if (!nodeToReplace || !replacementNode) {
return false;
}
if (this.left && this.nodeCompare(this.left, nodeToReplace) == 0) {
this.left = replacementNode;
return true;
}
if (this.right && this.nodeCompare(this.right, nodeToReplace) == 0) {
this.right = replacementNode;
return true;
}
return false;
}
/**
* @param {*} key
* @returns {boolean}
*/
contains(key) {
return !!this.findNode(key);
}
/**
* Finds right most child node
* @returns {BinaryTreeNode} The node with the maximum key value
* @readonly
*/
findMax() {
if (!this.right) {
return this;
}
return this.right.findMax();
}
/**
* Finds left most child node
* @returns {BinaryTreeNode} The node with the minimum key value
* @readonly
*/
findMin() {
if (!this.left) {
return this;
}
return this.left.findMin();
}
/**
* Finds a node by its `key` value
* @param {K} key Key of the searching node
* @returns {BinaryTreeNode|null} Node object or _null_ if the node was not found
*/
findNode(key) {
// Check this
if (this.keyComparator.equal(this.key, key)) {
return this;
}
if (this.keyComparator.lessThan(key, this.key) && this.left) {
// Check left nodes
return this.left.findNode(key);
}
if (this.keyComparator.greaterThan(key, this.key) && this.right) {
// Check right nodes
return this.right.findNode(key);
}
return null;
}
/**
* Traverses tree nodes up starting from the current node
* @returns {BinaryTreeNode[]} Readonly array of nodes
* @readonly
*/
*traverseUpIterator() {
let parentNode = this.parent;
while (parentNode) {
yield parentNode;
parentNode = parentNode.parent;
}
}
/**
* Traverses tree nodes and generate a stream of the node objects
* @param orderType
*/
*traverseDownIterator(orderType = "InOrder!") {
if (orderType == "PreOrder!") {
// Add root
yield this;
}
// Add left nodes
if (this.left) {
yield* this.left.traverseDownIterator(orderType);
}
if (orderType == "InOrder!") {
// Add root
yield this;
}
// Add right nodes
if (this.right) {
yield* this.right.traverseDownIterator(orderType);
}
if (orderType == "PostOrder!") {
// Add root
yield this;
}
}
/**
* Traverses tree nodes down starting from the current node
* @returns {BinaryTreeNode[]} Readonly array of nodes
* @readonly
*/
traverse(orderType = "InOrder!") {
return [...this.traverseDownIterator(orderType)];
}
/**
* Iterator
*/
*[Symbol.iterator]() {
yield* this.traverseDownIterator();
}
/**
* Adds a new node to this node
* @param node New node object
* @returns New node reference or `this` node if its `key` is identical to the key of `node`
*/
addNode(node) {
if (node) {
if (this.keyComparator.lessThan(node.key, this.key)) {
// Insert to the left.
if (this.left) {
return this.left.addNode(node);
}
this.setLeft(node);
return node;
}
if (this.keyComparator.greaterThan(node.key, this.key)) {
// Insert to the right.
if (this.right) {
return this.right.addNode(node);
}
this.setRight(node);
return node;
}
this.setValue(node.value);
}
return this;
}
/**
* Adds a new node to the current node
* @param key Key of the node
* @param value Node's value
* @returns {BinaryTreeNode}
*/
add(key, value) {
const newNode = new BinaryTreeNode(key, value, this.keyComparator);
return this.addNode(newNode);
}
/**
* Removes the node with the key `key` from the current node
* @param {K} key A key of the node to remove
* @returns {BinaryTreeNode|null} Removed node or `null` if the node was not found
*/
remove(key) {
const nodeToRemove = this.findNode(key);
if (!nodeToRemove) {
//throw new Error('Item not found in the tree');
return null;
}
const { parent } = nodeToRemove;
if (!nodeToRemove.left && !nodeToRemove.right) {
// Node is a leaf and thus has no children.
if (parent) {
// Node has a parent. Just remove the pointer to this node from the parent.
parent.removeChild(nodeToRemove);
}
else {
// Node has no parent. Just erase current node value.
nodeToRemove.setValue(null);
nodeToRemove.setLeft(null);
nodeToRemove.setRight(null);
}
}
else if (nodeToRemove.left && nodeToRemove.right) {
// Node has two children.
// Find the next biggest value (minimum value in the right branch)
// and replace current value node with that next biggest value.
const nextBiggerNode = nodeToRemove.right.findMin();
if (!(this.nodeCompare(nextBiggerNode, nodeToRemove.right) == 0)) {
this.remove(nextBiggerNode.key);
nodeToRemove.key = nextBiggerNode.key;
nodeToRemove.value = nextBiggerNode.value;
}
else {
// In case if next right value is the next bigger one and it doesn't have left child
// then just replace node that is going to be deleted with the right node.
nodeToRemove.key = nodeToRemove.right.key;
nodeToRemove.value = nodeToRemove.right.value;
nodeToRemove.setRight(nodeToRemove.right.right);
}
}
else {
// Node has only one child.
// Make this child to be a direct child of current node's parent.
const childNode = nodeToRemove.left || nodeToRemove.right;
if (childNode) {
if (parent) {
parent.replaceChild(nodeToRemove, childNode);
nodeToRemove.setLeft(null);
nodeToRemove.setRight(null);
nodeToRemove.setValue(null);
}
else {
BinaryTreeNode.copyNode(childNode, nodeToRemove);
}
}
}
// Clear the parent of removed node.
nodeToRemove.parent = null;
return nodeToRemove;
}
/**
* Returns the comma delimited string of tree keys
* @returns {string} String
*/
toString() {
return this.traverse().map(node => node.key).toString();
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BinaryTreeNode.js","sourceRoot":"","sources":["../../../../../../projects/cute-core/src/lib/collections/tree/BinaryTreeNode.ts"],"names":[],"mappings":"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","sourcesContent":["import { Comparator } from \"../../util/Comparator\";\r\nimport { Compare } from \"../../util/function/Compare\";\r\nimport { Element } from \"../Collection\";\r\n\r\nexport class BinaryTreeNode<K = any, V = any> {\r\n  left: BinaryTreeNode<K, V> | null = null;\r\n  right: BinaryTreeNode<K, V> | null = null;\r\n  parent: BinaryTreeNode<K, V> | null = null;\r\n  key: K;\r\n  value: Element<V> = null;\r\n  readonly data: Map<any, any> = new Map();\r\n  protected nodeCompare: Compare<Readonly<BinaryTreeNode<K, V>>> = Comparator.compare;\r\n  protected keyComparator: Comparator<K>;\r\n\r\n  constructor(key: K, value?: Element<V>, comparator?: Comparator<K>) {\r\n    this.value = value === undefined ? null : value;\r\n    this.key = key;\r\n    this.keyComparator = comparator ?? Comparator.getInstance();\r\n  }\r\n\r\n  /**\r\n   * @param {BinaryTreeNode} sourceNode\r\n   * @param {BinaryTreeNode} targetNode\r\n   * @static\r\n   */\r\n  static copyNode(sourceNode: BinaryTreeNode, targetNode: BinaryTreeNode): void {\r\n    targetNode.key = sourceNode.key;\r\n    targetNode.setValue(sourceNode.value);\r\n    targetNode.setLeft(sourceNode.left);\r\n    targetNode.setRight(sourceNode.right);\r\n  }\r\n\r\n  get height(): number {\r\n    return Math.max(this.leftHeight, this.rightHeight);\r\n  }\r\n\r\n  get leftHeight(): number {\r\n    if (!this.left) return 0;\r\n    return this.left.height + 1;\r\n  }\r\n\r\n  get rightHeight(): number {\r\n    if (!this.right) return 0;\r\n    return this.right.height + 1;\r\n  }\r\n\r\n  get balanceFactor(): number {\r\n    return this.leftHeight - this.rightHeight;\r\n  }\r\n  /**\r\n   * Get current node's sibling node if exists\r\n   * @returns {BinaryTreeNode}\r\n   */\r\n  get sibling(): BinaryTreeNode<K, V> | undefined {\r\n    // Check if current node has parent.\r\n    if (!this.parent) {\r\n      return undefined;\r\n    }\r\n    // So for now we know that current node has a parent and this\r\n    // parent has at least one children. Let's find out who is the brother.\r\n    if (this.nodeCompare(this, this.parent.left) == 0) {\r\n      // Right one is a sibling (if exists)\r\n      return this.parent.right ?? undefined;\r\n    }\r\n\r\n    // Left one is a sibling (if exists)\r\n    return this.parent.left ?? undefined;\r\n  }\r\n  /**\r\n   * Get parent's sibling if it exists.\r\n   * @returns {BinaryTreeNode}\r\n   */\r\n  get uncle(): BinaryTreeNode<K, V> | undefined {\r\n    // Check if current node has parent.\r\n    if (!this.parent) {\r\n      return undefined;\r\n    }\r\n\r\n    // Check if current node has grand-parent.\r\n    if (!this.parent.parent) {\r\n      return undefined;\r\n    }\r\n\r\n    // Check if grand-parent has two children.\r\n    if (!this.parent.parent.left || !this.parent.parent.right) {\r\n      return undefined;\r\n    }\r\n\r\n    // So for now we know that current node has grand-parent and this\r\n    // grand-parent has two children. Let's find out who is the uncle.\r\n    if (this.nodeCompare(this.parent, this.parent.parent.left) == 0) {\r\n      // Right one is an uncle.\r\n      return this.parent.parent.right;\r\n    }\r\n\r\n    // Left one is an uncle.\r\n    return this.parent.parent.left;\r\n  }\r\n  /**\r\n   * Gets the child direction of the current node relative to the parent node\r\n   * @returns `0` - if the node is the _left_ child, `1` - if the node is the _right_ child, `NaN` - node hasn't the parent node\r\n   */\r\n  get direction(): number {\r\n    if (this.parent) {\r\n      if (this.parent.left == this) {\r\n        return 0;\r\n      }\r\n      return 1;\r\n    }\r\n    return NaN;\r\n  }\r\n  /**\r\n   * @param {*} value\r\n   * @returns {boolean}\r\n   */\r\n  setValue(value: Element<V>): boolean {\r\n    if (value === undefined) return false;\r\n    this.value = value;\r\n    return true;\r\n  }\r\n  /**\r\n   * Sets a node as a left child node\r\n   * @param {BinaryTreeNode} node A new node to attach\r\n   * @returns {this} `this`\r\n   */\r\n  setLeft(node: BinaryTreeNode<K, V> | null): this {\r\n    // Reset parent for left node since it is going to be detached.\r\n    if (this.left) {\r\n      this.left.parent = null;\r\n    }\r\n\r\n    // Attach new node to the left.\r\n    this.left = node;\r\n\r\n    // Make current node to be a parent for new left one.\r\n    if (this.left) {\r\n      this.left.parent = this;\r\n    }\r\n\r\n    return this;\r\n  }\r\n  /**\r\n   * Sets a node as a right child node\r\n   * @param {BinaryTreeNode} node A new node to attach\r\n   * @returns `this`\r\n   */\r\n  setRight(node: BinaryTreeNode<K, V> | null): this {\r\n    // Reset parent for right node since it is going to be detached.\r\n    if (this.right) {\r\n      this.right.parent = null;\r\n    }\r\n\r\n    // Attach new node to the right.\r\n    this.right = node;\r\n\r\n    // Make current node to be a parent for new right one.\r\n    if (this.right) {\r\n      this.right.parent = this;\r\n    }\r\n\r\n    return this;\r\n  }\r\n  /**\r\n   * Removes a specified node if it was attached to this node as a child\r\n   * @param {BinaryTreeNode} nodeToRemove A node to remove if it is a child node\r\n   * @returns {boolean} _true_ if a node is a child node and it was removed successfully, else _false_\r\n   */\r\n  removeChild(nodeToRemove: BinaryTreeNode<K, V>): boolean {\r\n    if (this.left && this.nodeCompare(this.left, nodeToRemove) == 0) {\r\n      this.left = null;\r\n      return true;\r\n    }\r\n\r\n    if (this.right && this.nodeCompare(this.right, nodeToRemove) == 0) {\r\n      this.right = null;\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n  /**\r\n   * Replaces a child node\r\n   * @param {BinaryTreeNode} nodeToReplace\r\n   * @param {BinaryTreeNode} replacementNode\r\n   * @returns {boolean}\r\n   */\r\n  replaceChild(nodeToReplace: BinaryTreeNode<K, V>, replacementNode: BinaryTreeNode<K, V>): boolean {\r\n    if (!nodeToReplace || !replacementNode) {\r\n      return false;\r\n    }\r\n\r\n    if (this.left && this.nodeCompare(this.left, nodeToReplace) == 0) {\r\n      this.left = replacementNode;\r\n      return true;\r\n    }\r\n\r\n    if (this.right && this.nodeCompare(this.right, nodeToReplace) == 0) {\r\n      this.right = replacementNode;\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n  /**\r\n   * @param {*} key\r\n   * @returns {boolean}\r\n   */\r\n  contains(key: K): boolean {\r\n    return !!this.findNode(key);\r\n  }\r\n  /**\r\n   * Finds right most child node\r\n   * @returns {BinaryTreeNode}  The node with the maximum key value\r\n   * @readonly\r\n   */\r\n  findMax(): BinaryTreeNode<K, V> {\r\n    if (!this.right) {\r\n      return this;\r\n    }\r\n    return this.right.findMax();\r\n  }\r\n  /**\r\n   * Finds left most child node\r\n   * @returns {BinaryTreeNode} The node with the minimum key value\r\n   * @readonly\r\n   */\r\n  findMin(): BinaryTreeNode<K, V> {\r\n    if (!this.left) {\r\n      return this;\r\n    }\r\n    return this.left.findMin();\r\n  }\r\n  /**\r\n   * Finds a node by its `key` value\r\n   * @param {K} key   Key of the searching node\r\n   * @returns {BinaryTreeNode|null}   Node object or _null_ if the node was not found\r\n   */\r\n  findNode(key: K): BinaryTreeNode<K, V> | null {\r\n    // Check this\r\n    if (this.keyComparator.equal(this.key, key)) {\r\n      return this;\r\n    }\r\n\r\n    if (this.keyComparator.lessThan(key, this.key) && this.left) {\r\n      // Check left nodes\r\n      return this.left.findNode(key);\r\n    }\r\n\r\n    if (this.keyComparator.greaterThan(key, this.key) && this.right) {\r\n      // Check right nodes\r\n      return this.right.findNode(key);\r\n    }\r\n\r\n    return null;\r\n  }\r\n  /**\r\n   * Traverses tree nodes up starting from the current node\r\n   * @returns {BinaryTreeNode[]} Readonly array of nodes\r\n   * @readonly\r\n   */\r\n  *traverseUpIterator(): IterableIterator<BinaryTreeNode<K, V>> {\r\n    let parentNode = this.parent;\r\n    while (parentNode) {\r\n      yield parentNode;\r\n      parentNode = parentNode.parent;\r\n    }\r\n  }\r\n  /**\r\n   * Traverses tree nodes and generate a stream of the node objects\r\n   * @param orderType\r\n   */\r\n  *traverseDownIterator(orderType: \"PreOrder!\" | \"InOrder!\" | \"PostOrder!\" = \"InOrder!\"): IterableIterator<BinaryTreeNode<K, V>> {\r\n\r\n    if (orderType == \"PreOrder!\") {\r\n      // Add root\r\n      yield this;\r\n    }\r\n\r\n    // Add left nodes\r\n    if (this.left) {\r\n      yield* this.left.traverseDownIterator(orderType);\r\n    }\r\n\r\n    if (orderType == \"InOrder!\") {\r\n      // Add root\r\n      yield this;\r\n    }\r\n\r\n    // Add right nodes\r\n    if (this.right) {\r\n      yield* this.right.traverseDownIterator(orderType);\r\n    }\r\n\r\n    if (orderType == \"PostOrder!\") {\r\n      // Add root\r\n      yield this;\r\n    }\r\n\r\n  }\r\n  /**\r\n   * Traverses tree nodes down starting from the current node\r\n   * @returns {BinaryTreeNode[]} Readonly array of nodes\r\n   * @readonly\r\n   */\r\n  traverse(orderType: \"PreOrder!\" | \"InOrder!\" | \"PostOrder!\" = \"InOrder!\"): ReadonlyArray<BinaryTreeNode<K, V>> {\r\n    return [...this.traverseDownIterator(orderType)];\r\n  }\r\n  /**\r\n   * Iterator\r\n   */\r\n  *[Symbol.iterator](): IterableIterator<BinaryTreeNode<K,V>> {\r\n    yield* this.traverseDownIterator();\r\n  }\r\n  /**\r\n   * Adds a new node to this node\r\n   * @param node New node object\r\n   * @returns New node reference or `this` node if its `key` is identical to the key of `node`\r\n   */\r\n  addNode(node: BinaryTreeNode<K, V>): BinaryTreeNode<K, V> {\r\n    if (node) {\r\n      if (this.keyComparator.lessThan(node.key, this.key)) {\r\n        // Insert to the left.\r\n        if (this.left) {\r\n          return this.left.addNode(node);\r\n        }\r\n        this.setLeft(node);\r\n        return node;\r\n      }\r\n\r\n      if (this.keyComparator.greaterThan(node.key, this.key)) {\r\n        // Insert to the right.\r\n        if (this.right) {\r\n          return this.right.addNode(node);\r\n        }\r\n        this.setRight(node);\r\n        return node;\r\n      }\r\n\r\n      this.setValue(node.value);\r\n    }\r\n\r\n    return this;\r\n  }\r\n  /**\r\n   * Adds a new node to the current node\r\n   * @param key   Key of the node\r\n   * @param value Node's value\r\n   * @returns {BinaryTreeNode}\r\n   */\r\n  add(key: K, value: Element<V>): BinaryTreeNode<K, V> {\r\n    const newNode = new BinaryTreeNode(key, value, this.keyComparator);\r\n    return this.addNode(newNode);\r\n  }\r\n  /**\r\n   * Removes the node with the key `key` from the current node\r\n   * @param {K} key   A key of the node to remove\r\n   * @returns {BinaryTreeNode|null} Removed node or `null` if the node was not found\r\n   */\r\n  remove(key: K): Readonly<BinaryTreeNode<K, V>> | null {\r\n    const nodeToRemove = this.findNode(key) as BinaryTreeNode<K, V>;\r\n\r\n    if (!nodeToRemove) {\r\n      //throw new Error('Item not found in the tree');\r\n      return null;\r\n    }\r\n\r\n    const { parent } = nodeToRemove;\r\n\r\n    if (!nodeToRemove.left && !nodeToRemove.right) {\r\n      // Node is a leaf and thus has no children.\r\n      if (parent) {\r\n        // Node has a parent. Just remove the pointer to this node from the parent.\r\n        parent.removeChild(nodeToRemove);\r\n      } else {\r\n        // Node has no parent. Just erase current node value.\r\n        nodeToRemove.setValue(null);\r\n        nodeToRemove.setLeft(null);\r\n        nodeToRemove.setRight(null);\r\n      }\r\n    } else if (nodeToRemove.left && nodeToRemove.right) {\r\n      // Node has two children.\r\n      // Find the next biggest value (minimum value in the right branch)\r\n      // and replace current value node with that next biggest value.\r\n      const nextBiggerNode = nodeToRemove.right.findMin();\r\n      if (!(this.nodeCompare(nextBiggerNode, nodeToRemove.right) == 0)) {\r\n        this.remove(nextBiggerNode.key);\r\n        nodeToRemove.key = nextBiggerNode.key;\r\n        nodeToRemove.value = nextBiggerNode.value;\r\n      } else {\r\n        // In case if next right value is the next bigger one and it doesn't have left child\r\n        // then just replace node that is going to be deleted with the right node.\r\n        nodeToRemove.key = nodeToRemove.right.key;\r\n        nodeToRemove.value = nodeToRemove.right.value;\r\n        nodeToRemove.setRight(nodeToRemove.right.right);\r\n      }\r\n    } else {\r\n      // Node has only one child.\r\n      // Make this child to be a direct child of current node's parent.\r\n      const childNode = nodeToRemove.left || nodeToRemove.right;\r\n\r\n      if (childNode) {\r\n        if (parent) {\r\n          parent.replaceChild(nodeToRemove, childNode);\r\n          nodeToRemove.setLeft(null);\r\n          nodeToRemove.setRight(null);\r\n          nodeToRemove.setValue(null);\r\n        } else {\r\n          BinaryTreeNode.copyNode(childNode, nodeToRemove);\r\n        }\r\n      }\r\n    }\r\n\r\n    // Clear the parent of removed node.\r\n    nodeToRemove.parent = null;\r\n\r\n    return nodeToRemove;\r\n  }\r\n  /**\r\n   * Returns the comma delimited string of tree keys\r\n   * @returns {string} String\r\n   */\r\n   toString(): string {\r\n    return this.traverse().map(node => node.key).toString();\r\n  }\r\n\r\n}\r\n"]}