Update find-the-minimum-and-maximum-value-in-a-binary-search-tree.english.md (#35057)

Added solution which has been tested and confirmed to pass all tests

curriculum/challenges/english/08-coding-interview-prep/data-structures/find-the-minimum-and-maximum-value-in-a-binary-search-tree.english.md

@@ -108,6 +108,176 @@ BinarySearchTree.prototype = {
 <section id='solution'>
 
 ```js
-// solution required
+var displayTree = tree => console.log(JSON.stringify(tree, null, 2));
+
+function Node(value) {
+	this.value = value;
+	this.left = null;
+	this.right = null;
+}
+
+function BinarySearchTree() {
+	this.root = null;
+	this.findMin = function() {
+		// Empty tree.
+		if (!this.root) {
+			return null;
+		}
+		let currentNode = this.root;
+		while (currentNode.left) {
+			currentNode = currentNode.left;
+		}
+		return currentNode.value;
+	};
+	this.findMax = function() {
+		// Empty tree.
+		if (!this.root) {
+			return null;
+		}
+		let currentNode = this.root;
+		while (currentNode.right) {
+			currentNode = currentNode.right;
+		}
+		return currentNode.value;
+	};
+	this.add = function(value) {
+		// Empty tree.
+		if (!this.root) {
+			this.root = new Node(value);
+			return undefined;
+		}
+		return this.addNode(this.root, value);
+	};
+	this.addNode = function(node, value) {
+		// Check if value already exists.
+		if (node.value === value) return null;
+		if (value < node.value) {
+			if (node.left) {
+				return this.addNode(node.left, value);
+			} else {
+				node.left = new Node(value);
+				return undefined;
+			}
+		} else {
+			if (node.right) {
+				return this.addNode(node.right, value);
+			} else {
+				node.right = new Node(value);
+				return undefined;
+			}
+		}
+	};
+	this.isPresent = function(value) {
+		if (!this.root) {
+			return null;
+		}
+		return this.isNodePresent(this.root, value);
+	};
+	this.isNodePresent = function(node, value) {
+		if (node.value === value) return true;
+		if (value < node.value) {
+			return node.left ? this.isNodePresent(node.left, value) : false;
+		} else {
+			return node.right ? this.isNodePresent(node.right, value) : false;
+		}
+		return false;
+	};
+	this.findMinHeight = function() {
+		if (!this.root) {
+			return -1;
+		}
+		let heights = {};
+		let height = 0;
+		this.traverseTree(this.root, height, heights);
+		return Math.min(...Object.keys(heights));
+	};
+	this.findMaxHeight = function() {
+		if (!this.root) {
+			return -1;
+		}
+		let heights = {};
+		let height = 0;
+		this.traverseTree(this.root, height, heights);
+		return Math.max(...Object.keys(heights));
+	};
+	this.traverseTree = function(node, height, heights) {
+		if (node.left === null && node.right === null) {
+			return (heights[height] = true);
+		}
+		if (node.left) {
+			this.traverseTree(node.left, height + 1, heights);
+		}
+		if (node.right) {
+			this.traverseTree(node.right, height + 1, heights);
+		}
+	};
+	this.isBalanced = function() {
+		return this.findMaxHeight() > this.findMinHeight() + 1;
+	};
+	// DFS tree traversal.
+	this.inorder = function() {
+		if (!this.root) return null;
+		let result = [];
+
+		function traverseInOrder(node) {
+			if (node.left) traverseInOrder(node.left);
+			result.push(node.value);
+			if (node.right) traverseInOrder(node.right);
+		}
+		traverseInOrder(this.root);
+		return result;
+	};
+	this.preorder = function() {
+		if (!this.root) return null;
+		let result = [];
+
+		function traverseInOrder(node) {
+			result.push(node.value);
+			if (node.left) traverseInOrder(node.left);
+			if (node.right) traverseInOrder(node.right);
+		}
+		traverseInOrder(this.root);
+		return result;
+	};
+	this.postorder = function() {
+		if (!this.root) return null;
+		let result = [];
+
+		function traverseInOrder(node) {
+			if (node.left) traverseInOrder(node.left);
+			if (node.right) traverseInOrder(node.right);
+			result.push(node.value);
+		}
+		traverseInOrder(this.root);
+		return result;
+	};
+	// BFS tree traversal.
+	this.levelOrder = function() {
+		if (!this.root) return null;
+		let queue = [this.root];
+		let result = [];
+		while (queue.length) {
+			let node = queue.shift();
+			result.push(node.value);
+			if (node.left) queue.push(node.left);
+			if (node.right) queue.push(node.right);
+		}
+		return result;
+	};
+	this.reverseLevelOrder = function() {
+		if (!this.root) return null;
+		let queue = [this.root];
+		let result = [];
+		while (queue.length) {
+			let node = queue.shift();
+			result.push(node.value);
+			if (node.right) queue.push(node.right);
+			if (node.left) queue.push(node.left);
+		}
+		return result;
+	};
+	// Delete a leaf node.
+}
+let bst = new BinarySearchTree();
 ```
 </section>