The Best 5 Binary Tree Coding Questions to Master JavaScript

This article highlights five essential binary tree coding challenges that every JavaScript developer should tackle. Each question is designed to deepen your understanding of tree data structures and their applications in JavaScript programming.

In the world of computer science, binary trees are one of the most fundamental data structures. They are used in various algorithms and applications due to their efficiency and versatility. To master binary trees, it's crucial to practice solving problems that test your knowledge and application skills. Here are five essential binary tree coding questions that will help you hone your JavaScript programming abilities.

Question 1: Implementing a Binary Search Tree (BST)

Description: A Binary Search Tree (BST) is a special type of binary tree where each node has at most two children, and the left child is always less than the parent, while the right child is always greater. Implement a function that adds new nodes to a BST and another function that searches for a given value within the BST.

JavaScript Code Example:

class Node {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

class BinarySearchTree {
    constructor() {
        this.root = null;
    }

    insert(value) {
        const newNode = new Node(value);
        if (!this.root) {
            this.root = newNode;
        } else {
            this.insertNode(this.root, newNode);
        }
    }

    insertNode(node, newNode) {
        if (newNode.value < node.value) {
            if (node.left === null) {
                node.left = newNode;
            } else {
                this.insertNode(node.left, newNode);
            }
        } else {
            if (node.right === null) {
                node.right = newNode;
            } else {
                this.insertNode(node.right, newNode);
            }
        }
    }

    search(value) {
        return this.searchNode(this.root, value);
    }

    searchNode(node, value) {
        if (node === null || node.value === value) {
            return node;
        }
        if (value < node.value) {
            return this.searchNode(node.left, value);
        } else {
            return this.searchNode(node.right, value);
        }
    }
}

Question 2: Level Order Traversal of a Binary Tree

Description: Implement a function that performs a level order traversal (also known as breadth-first traversal) on a binary tree and returns an array of values in the order they were visited.

JavaScript Code Example:

function levelOrderTraversal(root) {
    const result = [];
    if (!root) {
        return result;
    }
    let queue = [root];
    while (queue.length > 0) {
        const current = queue.shift();
        result.push(current.value);
        if (current.left) {
            queue.push(current.left);
        }
        if (current.right) {
            queue.push(current.right);
        }
    }
    return result;
}

Question 3: Finding the Maximum Depth of a Binary Tree

Description: Write a function that calculates the maximum depth of a binary tree. The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

JavaScript Code Example:

function maxDepth(root) {
    if (!root) {
        return 0;
    }
    let leftDepth = maxDepth(root.left);
    let rightDepth = maxDepth(root.right);
    return Math.max(leftDepth, rightDepth) + 1;
}

Question 4: Checking if a Binary Tree is Balanced

Description: A binary tree is balanced if the heights of its left and right subtrees differ by no more than one. Implement a function that checks whether a binary tree is balanced.

JavaScript Code Example:

function isBalanced(root) {
    if (!root) {
        return true;
    }
    const leftHeight = height(root.left);
    const rightHeight = height(root.right);
    if (Math.abs(leftHeight - rightHeight) <= 1 && isBalanced(root.left) && isBalanced(root.right)) {
        return true;
    }
    return false;
}

function height(node) {
    if (!node) {
        return 0;
    }
    return Math.max(height(node.left), height(node.right)) + 1;
}

Question 5: Inverting a Binary Tree

Description: Invert a binary tree means to swap the left and right children of all nodes. Implement a function that takes the root of a binary tree and returns the inverted version of the tree.

JavaScript Code Example:

function invertTree(root) {
    if (!root) {
        return null;
    }
    const temp = root.left;
    root.left = invertTree(root.right);
    root.right = invertTree(temp);
    return root;
}

By practicing these coding questions, you can significantly improve your proficiency with binary trees in JavaScript. These exercises not only test your theoretical knowledge but also your ability to implement solutions efficiently. Happy coding!

原文出自：https://www.js-obfuscator.com/article/26675162.html