Finding Sum of Left Leaves of a BST in JavaScript

Problem

We are required to write a JavaScript function that takes in the root of a Binary Search Tree as the only argument.

The function should simply calculate the sum of data stored in the left leaves of the BST.

For example, if the Tree looks like this −

8
/ \
1 10
/ \
5 17

Then the output should be −

const output = 6;

Output Explanation:

Because there are two left leaves in the Tree with values 1 and 5.

Example

The code for this will be −

class Node{
   constructor(data) {
      this.data = data;
      this.left = null;
      this.right = null;
   };
};
class BinarySearchTree{
   constructor(){
      // root of a binary seach tree
      this.root = null;
   }
   insert(data){
      var newNode = new Node(data);
      if(this.root === null){
         this.root = newNode;
      }else{
         this.insertNode(this.root, newNode);
      };
   };
   insertNode(node, newNode){
      if(newNode.data < node.data){
         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);
         };
      };
   };
};
const BST = new BinarySearchTree();
BST.insert(5);
BST.insert(3);
BST.insert(6);
BST.insert(6);
BST.insert(9);
BST.insert(4);
BST.insert(7);
const isLeaf = node => {
   if (!node) return false;
      return (node.left === null && node.right === null);
}
const traverseTreeAndSumLeftLeaves = (root, sum = 0) => {
   if (!root) return sum;
   if (isLeaf(root)) return sum;
   if (root.left) {
      if (isLeaf(root.left)) {
         sum += root.left.data;
         traverseTreeAndSumLeftLeaves(root.left, sum);
      } else sum = traverseTreeAndSumLeftLeaves(root.left, sum);
   }
   if (root.right) {
      if (isLeaf(root.right)) return sum;
      else {
         sum = traverseTreeAndSumLeftLeaves(root.right, sum);
      }
   }
   return sum;
};
console.log(traverseTreeAndSumLeftLeaves(BST.root));

Output

The output in the console will be −

7