[Algorithm] Tree: Lowest Common Ancestor

By given a tree structure, task is to find lowest common ancestor:

 

For example, LCA(4, 5) --> >3

LCA(4,2) --> 1

LCA(3, 5) --> 3

LCA(6, 6) --> 6

 

Solution to solve the problem:

Found two path to the given two node, then compare two list to see from which point, they are no long equals:

?

1 2 3 4

[4,3,1] [5,6,3,1]    // the lowest common ancestor would be 3

　　

Code:

function createNode(val, left = null, right = null) {
  return {
    val,
    left,
    addLeft(leftKey) {
      return (this.left = leftKey ? createNode(leftKey) : null);
    },
    right,
    addRight(rightKey) {
      return (this.right = rightKey ? createNode(rightKey) : null);
    }
  };
}
function createBT(rootKey) {
  const root = createNode(rootKey);
  return {
    root,
    // Lowest Common Ancestor
    lca(root, j, k) {
      function helper(node, val) {
        let leftPath;
        let rightPath;
        if (!node) {
          return null;
        }

        // One we found the value,
        // constucte an array, then the path will be added to this array
        // thinking JS call stack, from bottom up
        // The way recusive works is found the base case, then do the bottom up
        if (node.val === val) {
          return [val];
        }

        if (node.left) {
          // If foudd will return an array
          // If not then will return null
          leftPath = helper(node.left, val);
          if (leftPath !== null) {
            leftPath.push(node.val);
            return leftPath;
          }
        }

        if (node.right) {
          // If foudd will return an array
          // If not then will return null
          rightPath = helper(node.right, val);
          if (rightPath !== null) {
            rightPath.push(node.val);
            return rightPath;
          }
        }

        return null;
      }

      const jPath = helper(root, j);
      const kPath = helper(root, k);
      let found = null;

      while (jPath.length > 0 && kPath.length > 0) {
        let fromJ = jPath.pop();
        let fromK = kPath.pop();
        if (fromJ === fromK) {
          found = fromJ;
        } else {
          break;
        }
      }

      return found;
    }
  };
}

const tree = createBT("1");
const root = tree.root;
const left = root.addLeft("3");
root.addRight("2");
const leftleft = left.addLeft("4");
const leftright = left.addRight("6");
const leftRighttleft = leftright.addLeft("5");

console.log(tree.lca(root, "6", "6")); // 6
console.log(tree.lca(root, "4", "5")); // 3
console.log(tree.lca(root, "4", "2")); // 1
console.log(tree.lca(root, "3", "4")); // 3