leetcode 863. All Nodes Distance K in Binary Tree 解题报告

最新推荐文章于 2021-07-28 07:48:11 发布

原创最新推荐文章于 2021-07-28 07:48:11 发布 · 428 阅读

0 ·

CC 4.0 BY-SA版权

OJ 同时被 2 个专栏收录

49 篇文章

订阅专栏

算法题解

17 篇文章

订阅专栏

本文介绍了一种将给定的二叉树转换为无向图的方法，并通过广度优先搜索（BFS）找到指定节点距离为K的所有节点。讨论了实现细节，包括使用邻接表表示图，以及如何避免重复访问节点。

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

题目

题目的大致意思是给出一个二叉树，一个二叉树上的点和一个距离，要求二叉树上所有距离这个点指定距离的其他点。
因为二叉树是有向的，基于它给出的数据很难在不使用其他数据结构的情况下直接求出这个点，所以我先用这个二叉树建立了一个无向图，再从给定节点对无向图进行广度优先遍历，从中找出深度为K的点，并将这些点返回。

性能上来说，开头对于给定的所有点进行了一次遍历，所以是O(N)，后面进行了一次不完全的BFS，肯定是小于等于O(N)的，所以整体时间复杂度是O(N)水平。

这里有一个问题是我中间使用了vector作为最后广搜时判断是否遍历的点(数组v)，即vector<bool> v(maxn,false)，其中maxn是前面建图时统计出来的点的最大值，在本地上是过了的，但是提交上去时会有runtime error，非常的迷。后来改成普通数组就没有问题了。

我所使用的方法对于K=0的时候不是很好判断，所以我直接在开头加了一个if，比较省事。

#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <cstring>
using namespace std;
/*
根据给定的二叉树，建立无向图，然后使用广度优先搜索输出所有深度为k的点。
*/

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
    vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
        vector<int> G[1005];
        stack<TreeNode*> q;
        q.push(root);
        int maxn = 0;

        //根据原有的二叉树建立图，使用数组邻接表
        while(!q.empty())
        {
            TreeNode* point = q.top();
            q.pop();
            if(point->val>maxn) maxn=point->val;

            if(point->left!=NULL)
            {
                G[point->val].push_back(point->left->val);
                G[point->left->val].push_back(point->val);
                q.push(point->left);
            }
            if(point->right!=NULL)
            {
                G[point->val].push_back(point->right->val);
                G[point->right->val].push_back(point->val);
                q.push(point->right);
            }
        }

        int start = target->val;
        queue<int> bfs;
        int v[1010];
        int d[1010];
        memset(v,0,sizeof(v));
        memset(d,0,sizeof(d));
        bfs.push(start);

        vector<int> ans;
        if(K==0)
        {
            ans.push_back(start);
            return ans;
        }

        while(!bfs.empty())
        {
            int node = bfs.front();
            bfs.pop();
            v[node] = true;

            for(unsigned int i = 0 ;i<G[node].size();i++)
            {
                int currentNode = G[node][i];
                if(!v[currentNode])
                {
                    v[currentNode] = true;
                    d[currentNode] = d[node]+1;

                    if(d[currentNode]==K)
                    {
                        ans.push_back(currentNode);
                    }
                    else
                    {
                        bfs.push(currentNode);
                    }
                }
            }
        }
        return ans;
    }
};

int main(void)
{
    Solution solution;
    TreeNode* t = new TreeNode(3);
    t->left = new TreeNode(5);
    t->right = new TreeNode(1);
    t->left->left = new TreeNode(6);
    t->left->right = new TreeNode(2);
    t->left->right->left = new TreeNode(7);
    t->left->right->right = new TreeNode(4);
    t->right->left = new TreeNode(0);
    t->right->right = new TreeNode(8);

    TreeNode* a = new TreeNode(0);
    a->left = new TreeNode(1);
    a->left->left = new TreeNode(3);
    a->left->left->left = new TreeNode(6);
    a->left->right = new TreeNode(2);
    a->left->right->left = new TreeNode(5);
    a->left->right->right = new TreeNode(4);

    TreeNode* s = new TreeNode(0);
    s->left = new TreeNode(1);
    s->left->right = new TreeNode(2);
    s->left->right->right = new TreeNode(3);
    s->left->right->right->right = new TreeNode(4);

    vector<int> ans(solution.distanceK(s,s->left->right->right,0));
    for(unsigned int i=0;i<ans.size();i++)
    {
        cout<<ans[i]<<endl;
    }
    return 0;
}