742 Closest Leaf in a Binary Tree

最新推荐文章于 2024-05-04 15:02:13 发布

原创最新推荐文章于 2024-05-04 15:02:13 发布 · 192 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#DataBricks

Medium 同时被 3 个专栏收录

178 篇文章

订阅专栏

Solved

160 篇文章

订阅专栏

Tree

29 篇文章

订阅专栏

本文探讨了一种高效的算法，用于在给定的二叉树中找到距离特定目标节点最近的叶节点。通过递归地构建从根节点到目标节点的路径，并对路径上的每个节点进行深度优先搜索，可以确定与目标节点距离最近的叶节点。此算法适用于各种二叉树结构，包括不平衡树。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 题目

Given a binary tree where every node has a unique value, and a target key k, find the value of the nearest leaf node to target k in the tree.

Here, nearest to a leaf means the least number of edges travelled on the binary tree to reach any leaf of the tree. Also, a node is called a leaf if it has no children.

In the following examples, the input tree is represented in flattened form row by row. The actual root tree given will be a TreeNode object.

Example 1:

Input:
root = [1, 3, 2], k = 1
Diagram of binary tree:
          1
         / \
        3   2

Output: 2 (or 3)

Explanation: Either 2 or 3 is the nearest leaf node to the target of 1.

Example 2:

Input:
root = [1], k = 1
Output: 1

Explanation: The nearest leaf node is the root node itself.

Example 3:

Input:
root = [1,2,3,4,null,null,null,5,null,6], k = 2
Diagram of binary tree:
             1
            / \
           2   3
          /
         4
        /
       5
      /
     6

Output: 3
Explanation: The leaf node with value 3 (and not the leaf node with value 6) is nearest to the node with value 2.

2 尝试解

2.1 分析

在二叉树上，求与给定的节点最近的叶节点。

指定节点Target到叶节点有两种方式，一种通过其左右子节点到达叶节点，一种通过其父节点到达其它叶节点。所以首先求出根节点Root到Target的路径Path，即Target的所有父节点及其自身。对于Path中的每一个节点，求出通过其左右子节点到达叶节点的最短路径再加上该节点到Target的距离，最后选其中的最小值即可。

2.2 代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void Closest(TreeNode* root,pair<int,int>&result,int dis){
        if(!root || dis >= result.first) return;
        if(!root->left&&!root->right&&dis < result.first){
            result.first = dis;
            result.second = root->val;
            return;
        }
        if(root->left) Closest(root->left,result,dis+1);
        if(root->right) Closest(root->right,result,dis+1);
    
    }
    void find(vector<TreeNode*>&path,int&k,vector<TreeNode*>&result){
        auto root = path.back();
        if(!root) return;
        if(root->val != k){
            path.push_back(root->left);
            find(path,k,result);
            path.pop_back();
            path.push_back(root->right);
            find(path,k,result);
            path.pop_back();
        }
        else{
            result = path;
        }
    }
    int findClosestLeaf(TreeNode* root, int k) {
        vector<TreeNode*>  path{root},parent;
        find(path,k,parent);
        pair<int,int> result(INT_MAX,-1);
        for(int i = parent.size()-1;i>=0; i--){
            Closest(parent[i],result,parent.size()-i-1);
        }
        return result.second;
    }
};

3 标准解