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

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

返回到目标结点 target 距离为 k 的所有结点的值的列表。 答案可以以 任何顺序 返回。
算法：
方法一： 转换成有向图，BFS
注意力不够集中！，错了很多次

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func distanceK(root *TreeNode, target *TreeNode, k int) []int {
    // 转换成无向图，然后bfs
    graph := make([][]int, 501)
    var dfs func(node *TreeNode)
    dfs = func(node *TreeNode) {
        if node == nil {
            return 
        }
   
        if node.Left != nil {
            graph[node.Val] = append(graph[node.Val], node.Left.Val)
            graph[node.Left.Val] = append(graph[node.Left.Val], node.Val)
            dfs(node.Left)
        }
        if node.Right != nil {
            graph[node.Val] = append(graph[node.Val], node.Right.Val)
            graph[node.Right.Val] = append(graph[node.Right.Val], node.Val)
            dfs(node.Right)
        }
        
    }
    dfs(root)
    if k == 0 {
        return []int{target.Val}
    }
    queue := graph[target.Val]
    visited := map[int]bool{}
    visited[target.Val] = true
    // fmt.Println(graph)
    for len(queue) > 0 && k > 1  {
        count := len(queue)
        // fmt.Println(queue, visited, k, count)
        k --
        // 将当前节点的所有下一层节点加入到queue中
        for i := range queue {
            if !visited[queue[i]] {
                visited[queue[i]] = true
                for _, v := range graph[queue[i]] {
                    if !visited[v] {
                        // visited[v] = true
                        queue = append(queue, v)
                    }
              }
            }  
        }


        queue = queue[count:]
    }
    return queue
}

方法二：DFS
一个节点有父节点，左节点，右节点，from备注DFS的上一个节点。不是从from节点来的，就继续遍历，并且depth ++

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func distanceK(root *TreeNode, target *TreeNode, k int) []int {
    // 转换成无向图，然后bfs
    parent := make(map[*TreeNode]*TreeNode, 0)
    var dfs func(node *TreeNode)
    dfs = func(node *TreeNode) {
        if node == nil {
            return 
        }
   
        if node.Left != nil {
            parent[node.Left] = node
            dfs(node.Left)
        }
        if node.Right != nil {
            parent[node.Right] = node
            dfs(node.Right)
        }
        
    }
    dfs(root)
    ans := make([]int, 0)
    var findans func(node, from *TreeNode, depth int)
    findans = func(node, from *TreeNode, depth int) {
        if node == nil {
            return 
        }
        if depth == k {
            ans = append(ans, node.Val)
            return
        }
        if node.Left != from {
            findans(node.Left, node, depth + 1)
        }
        if node.Right != from {
            findans(node.Right, node, depth + 1)
        }
        if parent[node] != from {
            findans(parent[node], node, depth + 1)
        }
    }
    findans(target, nil, 0)
    return ans
}