zoukankan      html  css  js  c++  java
  • [Algorithm] Given the root to a binary tree, return the deepest node

    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"}
  • 相关阅读:
    111. Minimum Depth of Binary Tree (Tree; DFS)
    124. Binary Tree Maximum Path Sum (Tree; DFS)
    99. Recover Binary Search Tree (Tree; DFS)
    129. Sum Root to Leaf Numbers(Tree; DFS)
    PAT 1073 Scientific Notation
    PAT 1050 String Subtraction
    PAT 1037 Magic Coupon
    PAT 1066 Root of AVL Tree
    PAT 1053 Path of Equal Weight
    PAT 1040 Longest Symmetric String
  • 原文地址:https://www.cnblogs.com/Answer1215/p/10513146.html
Copyright © 2011-2022 走看看