[Algorithm] Given the root to a binary tree, return the deepest node

最新推荐文章于 2023-11-11 09:00:00 发布

转载最新推荐文章于 2023-11-11 09:00:00 发布 · 143 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Answer1215/p/10513146.html

本文介绍了一种使用递归方法在二叉树中找到最深节点的算法。通过创建节点和二叉树，利用递归函数遍历树的左右子叶，直到到达没有子叶的节点，返回其深度和节点值。

By given a binary tree, and a root node, find the deepest node of this tree.

We have way to create node:

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);
    }
  };
}

Way to create tree:

function createBT(rootKey) {
  const root = createNode(rootKey);
  return {
    root,
    deepest(node) {
      // code goes here
    }
  };
}

Way to construct tree:

const tree = createBT("root");
const root = tree.root;
const left = root.addLeft("left");
root.addRight("right");

const leftleft = left.addLeft("left.left");
const leftleftleft = leftleft.addLeft("left.left.left");
const leftright = left.addRight("left.right");
leftright.addLeft("left.right.left");

The way to solve the problem is recursive calling the 'deepest' function for node's left and right leaf, until we reach the base case, which is the node that doesn't contian any left or right leaf.

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,
    deepest(node) {
      function helper(node, depth) {
        if (node && !node.left && !node.right) {
          return {
            depth,
            node
          };
        }

        if (node.left) {
          return helper(node.left, depth + 1);
        } else if (node.right) {
          return helper(node.right, depth + 1);
        }
      }

      const { depth: ld, node: ln } = helper(root.left, 1);
      const { depth: rd, node: rn } = helper(root.right, 1);

      const max = Math.max(ld, rd);
      if (max === ld) {
        return { depth: ld, node: ln.val };
      } else {
        return { depth: rd, node: rn.val };
      }
    }
  };
}

const tree = createBT("root");
const root = tree.root;
const left = root.addLeft("left");
root.addRight("right");

const leftleft = left.addLeft("left.left");
const leftleftleft = leftleft.addLeft("left.left.left");
const leftright = left.addRight("left.right");
leftright.addLeft("left.right.left");

console.log(tree.deepest(root)); // {depth: 3, node: "left.left.left"}

转载于:https://www.cnblogs.com/Answer1215/p/10513146.html