LeetCode 863 二叉树中所有距离为K的结点

题目

给定一个二叉树（具有根结点 root）， 一个目标结点 target ，和一个整数值 K 。

返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。

• 示例 1：

  输入：root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, K = 2

  输出：[7,4,1]

• 解释： 所求结点为与目标结点（值为 5）距离为 2 的结点，值分别为 7，4，以及 1

注意，输入的 "root" 和 "target" 实际上是树上的结点。 上面的输入仅仅是对这些对象进行了序列化描述。

提示：

• 给定的树是非空的，且最多有 K 个结点。

• 树上的每个结点都具有唯一的值 0 <= node.val <= 500 。

• 目标结点 target 是树上的结点。

• 0 <= K <= 1000.

我的代码

/**
 * 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:
    vector<int> res;
    int length;
    TreeNode* newTarget = NULL;
    TreeNode* dfs(TreeNode* root, TreeNode* target){ //返回target的父节点
        if(root->left == target || root->right == target){
            newTarget = root;
            return root;
        }
        if(root->left != NULL){
            dfs(root->left,target);
        }
        if(root->right != NULL){
            dfs(root->right,target);
        }
        return NULL;
        
    }
    void down(TreeNode* target, int k){ //向下寻找
        int i=0,j=0;
        deque<TreeNode*> q_first, q_second;
	    q_first.push_back(target);
	    while(!q_first.empty()) {
            if(i==k){//赋值
                for(j=0;j<q_first.size();j++){
                    res.push_back(q_first[j]->val);
                }
                q_first.clear();
                return ;
            }
		    while (!q_first.empty()) {
			    TreeNode *temp = q_first.front();
		    	q_first.pop_front();
		    	if(temp->left!=NULL)
			    	q_second.push_back(temp->left);
			    if(temp->right!=NULL)
				    q_second.push_back(temp->right);
		    }
            i++;
		    q_first.swap(q_second);
	    }
        return ;
    }
    void up(TreeNode* upT, TreeNode* target, int k){ //父节点的另一边寻找  T节点的父节点  T ,k
        if(k == 0){
            res.push_back(target->val);
            return ;
        }
        if(k == 1){
            res.push_back(upT->val);
            return ;
        }
        if(upT->left == target){
            if(upT->right){
                down(upT->right, k-2);
            }
        }else if(upT->right == target){
            if(upT->left){
                down(upT->left, k-2);
            }
        }else{
            return ;
        }
    }
    vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
        res.clear();
        if(K == 0){
            res.push_back(target->val);
            return res;
        }
        down(target, K); //下部
        //上部
        
        while(root->val != target->val && K>0){
            newTarget=NULL;
            dfs(root,target);
            if(newTarget){
                up(newTarget,target,K);
                target = newTarget;
            }
            
           
            K--;
        }
        return res;
        
    }
};

dfs函数

传入root根节点以及target节点，返回target节点的父节点

down函数

传入target节点以及距离k，向下寻找距离target节点距离为k的节点。

up函数

传入target的父节点upT，target节点，距离k。 向上（父节点的另一边）寻找距离target节点距离为k的节点。

主函数逻辑

从当前节点target-距离k做一次down()寻找下方节点，然后逐步向上走，更新target为target的父节点。