863. 二叉树中所有距离为 K 的结点---dfs/bfs

题目出处：https://leetcode-cn.com/problems/all-nodes-distance-k-in-binary-tree/

思路：1. 以target为根节点，做深度为k的深度优先遍历。若target不为根节点，则需要知道他的父节点是谁，故在深度优先遍历之前需要用一个哈希表记录每个节点的父节点。因此用根节点做一次深度优先遍历记录每个节点的父节点。

     2. 为了保证每次递归均往深处递归，不返回递归，就需要传入先前节点，在保证往深处递归的节点不为先前节点的条件下，进行递归。若深度到达k，则将当前节点的值记录入ans。

深度优先遍历

/**
 * 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 {
private:    
    unordered_map<TreeNode*, TreeNode*> mp; 
    vector<int> ans;   
public:
    void findParent(TreeNode* node){
        if(node->left){
            mp[node->left] = node;
            findParent(node->left);
        }

        if(node->right){
            mp[node->right] = node;
            findParent(node->right);
        }
    }
    void dfs(TreeNode* node, TreeNode* pre, int &k, int depth){
        if(!node){
            return; 
        }

        if(depth == k){
            ans.push_back(node->val);
            return;
        }

        if(node->left != pre){ 
           dfs(node->left, node, k, depth+1);
        }
        if(node->right != pre){
           dfs(node->right, node, k, depth+1);
        }
        if(mp[node] != pre){
           dfs(mp[node], node, k, depth+1);
        }
    }
    vector<int> distanceK(TreeNode* root, TreeNode* target, int k) {
        findParent(root);

        dfs(target, nullptr, k, 0);  //深度搜索

        return ans;
    }
};

广度优先遍历

/**
 * 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 {
private:    
    unordered_map<TreeNode*, TreeNode*> mp; 
    vector<int> ans;   
public:
    void findParent(TreeNode* node){
        if(node->left){
            mp[node->left] = node;
            findParent(node->left);
        }

        if(node->right){
            mp[node->right] = node;
            findParent(node->right);
        }
    }
    void bfs(TreeNode* node, int &k){
        queue<pair<TreeNode*, TreeNode*>> q;
        q.push({node, nullptr});
        
        for(int i = 0; i < k; ++i){   //向外扩k层
            int n = q.size();
            for(int t = 0; t < n; ++t){    //处理每层的结果
                TreeNode* now = q.front().first;
                TreeNode* pre = q.front().second;
                q.pop(); 
                if(now->left != pre && now->left){
                    q.push({now->left, now});
                }
                if(now->right != pre && now->right){
                    q.push({now->right, now});
                }
                if(mp[now] != pre && mp[now]){
                    q.push({mp[now], now});               
                }
            }
        }

        while(!q.empty()){
            ans.push_back(q.front().first->val);
            q.pop(); 
        }
    }
    vector<int> distanceK(TreeNode* root, TreeNode* target, int k) {
        findParent(root);

        bfs(target, k); 
        return ans;
    }
};