Java程序，用于在二叉树中的节点被激发时查找所有未燃烧的节点

假设一个二进制节点着火，一个随机节点（给定）被烧毁，1秒后连接到此节点的所有节点都被烧毁，1秒后，连接到这些烧毁节点的所有节点都被烧毁

k秒后，还有哪些节点

在这个二叉树中，假设节点D被烧掉，1秒后，节点B、E和C将开始烧掉，再过1秒，节点F和A将烧掉。在这之后，G将烧掉，然后下一秒，我将烧掉，然后，H将烧掉

---

在这个二叉树中，假设节点D被烧毁[看起来像是学生的练习；-）这不是学生的练习，但我一直在试图找到最佳解决方案。我在想一个更好的解决方案，我的方法是，我将根节点设为0，我将在右侧子节点上加+1，在左侧子节点上加-1。然后我将取第一个烧掉的节点值，然后取绝对差值of首先烧掉节点值和所有其他节点，并将其放在树状图中，其中节点为键，值为绝对差。但这失败了。即使我找到了蛮力方法继续，我也会编写代码。因此，基本上这是一个在（排序？）中执行节点删除的练习树。如果您不需要中间步骤，而只需要最终状态，则可以通过在每个步骤后不平衡树来节省CPU周期，特别是如果在后续步骤中删除了平衡的节点。另一个挑战是，您必须从一个节点“上下”移动。答案是否正确“k秒后，还有哪些节点？”是一个新树还是一组节点值？答案的一部分"是对问题的评论。你应该为这些问题添加评论。并且尽量礼貌一点；-）你说得很有道理，但我讨厌那些从未尝试过却仍然提出问题的人。更糟糕的是，我不能给出真正正确的答案，因为他们没有提出任何关于他希望如何存储数据的要求。我该怎么回答我已经给了他们所有的逻辑。如果他们来到这里，那么这就是他们应该期待的，对吗？如果我应该删除部分或全部模板，请通知我，我的定义不准确，被带走了。

import java.util.LinkedList;

import java.util.Scanner;

public class Test2 {

private static Character[] toArray (LinkedList<Character> L, char Char) {
    Character[] ReturnedList = new Character[L.size() + 1];
    for(int i=0; i<L.size(); i++) {
        ReturnedList[i] = L.get(i);
    }
    ReturnedList[L.size()-1] = Char; // It needs to be longer because it's used for the left and right
    //nodes, and they need an extra L or R to show they are on the left or right side
    return ReturnedList;
}
private static class Node { // for binary tree
    LinkedList <Character> spot = new LinkedList <Character>();
    Node left  = new Node(toArray(spot, 'L'));
    Node right = new Node(toArray(spot, 'R')); // left side and right side extention of tree, may stay as null
    boolean isBurned = false; 

    char name = ' '; // unused.
    //https://stackoverflow.com/questions/55108957/java-program-to-find-all-the-unburned-nodes-when-a-node-in-binary-tree-is-fired/55109092#55109092
    public Node(Character [] args) { // either L [left] or R [right]
        for(int i=0; i<args.length; i++) {
            spot.add(args[i]);
        }
    }

}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner sc = new Scanner (System.in);
    Node tree = new Node(new Character[0]);
    tree.name = 'F';
    tree.left.name = 'B';
    tree.right.name = 'G';
    tree.left.left.name = 'A'; //tree is a node
    tree.left.right.left.name = 'C';
    tree.right.right.name = 'I';
    tree.right.right.left.name = 'H';
    tree.left.right.name = 'D';
    tree.left.right.right.name = 'E';

    //[set a node on fire with whatever you'd like]
    tree.left.right.left.isBurned = true;
    LinkedList <Character[]> Queue = new LinkedList<Character[]>();
    Character [] placeholder = {'L', 'R', 'L'};
    Queue.add(placeholder);

    int seconds = sc.nextInt();

    while(!Queue.isEmpty()) {
        ///////////Variables/////////
        Character[] X = Queue.pop(); // List of directions
        Node Y = new Node(X);
        Y = tree; // start here and go down
        ///////////Location//////////
        for(int i=0; i<X.length; i++) {
            if(X[i] == 'L') {
                Y = Y.left; // keep on going right or left.
            }
            else {
                Y = Y.right;
            }
            ///////////Burning///////////////

            //Think about it. How would you find a node that is connected to the burning node?
            //Don't forget to add newly burning nodes, and don't add nodes that have already burned.
            //The character array, X, is a way you could manage this with.
        }

    }

    /*
         F
        / \
       /   \
      B     G
     / \     \
    A   D     I
       / \   /
      C   E H
     */
    }

}