Lowest Common Ancestor in a Binary Tree in Javascript

lowestCommonAncestor.js

/*
 Taking this tree as an example the output for 
 lowestCommonAncestor('k', 'j') => e
       a
      / \
     b   c
    / \
   d   e
      / \
     f   g
    / \   \
   h   i   j
      / 
     k
*/

const tree = {
  a: {
    parent: null,
  },
  b: {
    parent: 'a',
  },
  c: {
    parent: 'a',
  },
  d: {
    parent: 'b',
  },
  e: {
    parent: 'b',
  },
  f: {
    parent: 'e',
  },
  g: {
    parent: 'e',
  },
  h: {
    parent: 'f',
  },
  i: {
    parent: 'f',
  },
  j: {
    parent: 'g',
  },
  k: {
    parent: 'i',
  },
};

function getDepth(node) {
  if (tree[node].parent) {
    return getDepth(tree[node].parent) + 1;
  }
  return 0;
}

function walkN(node, n) {
  if (n === 0) {
    return node;
  }
  return walkN(tree[node].parent, n - 1);
}

function lowestCommonAncestor(a, b) {
  const depthA = getDepth(a);
  const depthB = getDepth(b);
  let result;
  let startNodeA = a;
  let startNodeB = b;

  if (depthA > depthB) {
    startNodeA = walkN(a, depthA - depthB);
  }
  if (depthB > depthA) {
    startNodeB = walkN(b, depthB - depthA);
  }

  while (!result) {
    if (tree[startNodeA].parent) {
      startNodeA = tree[startNodeA].parent;
    }
    if (tree[startNodeB].parent) {
      startNodeB = tree[startNodeB].parent;
    }
    if (startNodeA === startNodeB) {
      result = startNodeB;
    }
  }
  console.log(result);
}

lowestCommonAncestor('k', 'j');