Java中的父子树

Question

我试图实现一个类节点来构建一个节点树。 基本上，每个节点都可以有孩子，所以如果我指定多个节点，我可以用它构建一棵树。 举个例子：

node1 (the root) has node2 and node3 as children
node2 has node4 and node5 as children

我要解决的问题是构建这棵树并找到给定元素的所有子元素（在这种情况下，node1 将有 4 个子元素，因为它首先有 node2 和 node3，而 node2 有 2 个子元素，所以在共 4). 有人有什么建议吗？

编辑：

package ex1;

import java.sql.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Node {

  private String name;
  private String description;

  private ArrayList<Node> children = new ArrayList<>();

  Node(String name, String description){
    this.name = name;
    this.description = description;
  }

  private void setName(String name){
    this.name = name;
  }

  private void setDescription(String description) {
    this.description = description;
  }

  public void addChildren(Node child) {
    this.children.add(child);
  }

  public String getName() {
    return this.name;
  }

  public String getDescription() {
    return this.description;
  }

  public boolean hasDescription() {
    return !description.isEmpty();
  }

  public Collection<Node> getChildren() {
    return this.children;
  }

  /*
  public Node findNodeByName(String name, Node t) {
    if (t.getName().equals(name))
      return t;
    t.getChildren().forEach(node -> node.findNodeByName(name,node));
    return null;
  }*/

  public Node findNodeByName(String name, Node t){
    if(t.getName().equals(name)){
      return t;
    }
    else if (t.getChildren().size() != 0){
      for(Node c: children){
        Node ret = c.findNodeByName(name,c);
        if(ret != null){
          return ret;
        }
      }
    }
    return null;
  }



  // IMPORTANT: Don't change this method!
  private String toString(int indentNo) {
    String indent = "\t".repeat(indentNo);
    StringBuffer b = new StringBuffer();
    b.append(indent);
    b.append(getClass().getSimpleName() + " '" + getName() + "' ");

    if (hasDescription()) {
      b.append("(description: " + getDescription() + ")");
    }

    b.append("\n");

    for (Node node : getChildren()) {
      b.append(node.toString(indentNo + 1));
    }

    return b.toString();
  }

  @Override
  public String toString() {
    return toString(0);
  }
}

我使用类的方法：

Path path = Path.of(pathname);

String fileContent = null;
try {
   fileContent = Files.readString(path);
} catch (IOException e) {
   throw new RuntimeException(e);
}
List<String> lines = new ArrayList<>(Arrays.asList(fileContent.split("\n")));
String[] firstLine = lines.get(0).split(",");
Node parentNode = new Node(firstLine[0], firstLine[1]);
lines.remove(0);

/* This was just to test findNodeByName
for(String line: lines) {
   String[] params = line.split(",");
   System.out.println(params[2] + ": " + (parentNode.findNodeByName(params[2], parentNode) != null));
}*/
//Now we read all remaining data

Node tmpNode;
for(String line: lines) {
   String[] params = line.split(",");
   if (parentNode.findNodeByName(params[2])==null || parentNode.findNodeByName(params[0])!=null) //if parent was not found or name already exists
         throw new IOException();
   tmpNode = parentNode.findNodeByName(params[2]);
   tmpNode.addChildren(new Node(params[0],params[1]));
}

CSV 文件我从以下位置获取数据：

uni,"This is my university folder",
firstyear,,uni
secondyear,,uni
analysis,"folder for the analysis course",firstyear
ai,"folder for the artificial intelligence course",secondyear
db,"folder for the database course",firstyear

Answer 1

以下是一些可以提供帮助的示例代码（下面的解释）：

主类：

class Main {
  public static void main(String[] args) {
    Node v1 = new Node(1);
    Node v2 = new Node(2);
    Node v3 = new Node(3);
    Node v4 = new Node(4);
    Node v5 = new Node(5);
    v1.addChild(v2);
    v1.addChild(v3);
    v2.addChild(v4);
    v2.addChild(v5);
    v1.printChildren();
  }
}

节点类：

import java.util.*;
class Node{
  private int val;
  private ArrayList<Node> children = new ArrayList<Node>();
  public Node(int v){
    val = v;
  }
  public void addChild (Node c){
    children.add(c);
  }
  public void printChildren(){
    if (children.size() != 0){
      System.out.print("Children of Node " + getValue() + ": ");
      for(Node c: children){
        System.out.print("Node " + c.getValue() + " ");
      }
      System.out.println();
      for(Node c: children){
        c.printChildren();
      }
    }
  }
  public int getValue(){
    return val;
  }
}

输出：

Children of Node 1: Node 2 Node 3 
Children of Node 2: Node 4 Node 5 

好的，所以在我们的节点类中，假设每个节点都有一个整数值val 。 这是我们的第一个私有实例变量。 其次，每个节点都会有一个子节点列表children 。

当我们第一次声明我们的节点时，它们将具有整数值，如我们的构造函数所示。

定义节点后，我们可以将一些节点作为子节点添加到其他节点（v2 和 v3 是 v1 的子节点，v4 和 v5 是 v2 的子节点）。

现在我们需要打印它们。 我们将为此使用递归方法。 如果我们正在打印其子节点的节点有子节点（我们的子节点 ArrayList 的长度不为零），那么我们将首先遍历该列表，并打印出当前节点的子节点。 之后，我们再次遍历每个子节点并使用相同的方法（递归）打印出该节点的子节点。

我希望这有帮助！ 如果您需要任何进一步的帮助或澄清，请告诉我:)

编辑：

添加了一个getName()方法：

public String getName(){
   return "Node" + getValue();
}

添加了请求的方法：

  public Node findChildNodeByValue(int v){
    if(getValue() == v){
      System.out.println(getName() + " has the value");
      return new Node(getValue());
    }
    else if (children.size() != 0){
      for(Node c: children){
        Node ret = c.findChildNodeByValue(v);
        if(ret != null){
          return ret;
        }
      }
    }
    return null;
  }

快速说明：与原始方法非常相似，我们使用递归方法遍历每个节点的子节点：一旦我们到达一个没有更多子节点的节点，我们返回 null。 一旦我们到达具有给定值的节点，我们就会返回该节点的副本，该副本将被发送回调用函数的任何地方。

还编辑了主要方法：

Node v1 = new Node(1);
Node v2 = new Node(2);
Node v3 = new Node(3);
Node v4 = new Node(4);
Node v5 = new Node(5);
v1.addChild(v2);
v1.addChild(v3);
v2.addChild(v4);
v2.addChild(v5);
// v1.printChildren();
Node valNode = v1.findChildNodeByValue(5);
System.out.println(valNode.getName());

输出：

Node5 has the value
Node5

第二次编辑：

将方法更改为如下所示：

  public Node findNodeByName(String name){
    if(getName().equals(name)){
      Node t = new Node(getName(), getDescription());
      return t;
    }
    else if (getChildren().size() != 0){
      for(Node c: children){
        Node ret = c.findNodeByName(name);
        if(ret != null){
          return ret;
        }
      }
    }
    return null;
  }

主要方法应如下所示：

Node v1 = new Node("a","aa");
Node v2 = new Node("b","bb");
Node v3 = new Node("c","cc");
Node v4 = new Node("d","dd");
Node v5 = new Node("e","ee");
v1.addChildren(v2);
v1.addChildren(v3);
v2.addChildren(v4);
v2.addChildren(v5);

System.out.println(v1.findNodeByName("e"));

输出：

Node 'e' (description: ee)

第三次编辑：

添加了一个新方法：

public void setChildren(ArrayList<Node> c){
   children = c;
}

编辑方法：

  public Node findNodeByName(String name){
    if(getName().equals(name)){
      Node t = new Node(getName(), getDescription());
      t.setChildren(getChildren());
      return t;
    }
    else if (getChildren().size() != 0){
      for(Node c: children){
        Node ret = c.findNodeByName(name);
        if(ret != null){
          return ret;
        }
      }
    }
    return null;
  }

主要方法：

Node v1 = new Node("a","aa");
Node v2 = new Node("b","bb");
Node v3 = new Node("c","cc");
Node v4 = new Node("d","dd");
Node v5 = new Node("e","ee");
Node v6 = new Node("f","ff");
v1.addChildren(v2);
v1.addChildren(v3);
v2.addChildren(v4);
v2.addChildren(v5);
v4.addChildren(v6);

Node vNew = v1.findNodeByName("d");
System.out.println(vNew);
System.out.println(vNew.getChildren());

输出：

Node 'd' (description: dd)
    Node 'f' (description: ff)

[Node 'f' (description: ff)
]

Answer 2

根据您的要求，您正在寻找特定节点的所有后代/子节点。 然后广度优先深度搜索更适合这个用例。 围绕这些算法已经有大量的讨论。 例如：

广度优先搜索和深度优先搜索

您已经在思考与其 DataStructure 相关的正确方向。 我建议使用java泛型的一件事，以便它可以根据需要支持多种数据类型。

class Node<T> {
    
    T value;
    List<T> children;
    
    Node(T t) {
        this.value = t;
        children = new ArrayList<T>();
    }
    
    void addChild(T child) {
        children.add(child);
    }
}

Answer 3

递归方法调用的返回值被解除。

线

t.getChildren().forEach( node -> findNodeByName(name, node));

引发递归调用，但返回值不用于形成封闭方法的返回值。

相反，我们需要类似的东西

for (Node node : t.getChildren()) {
    Node result = findNodeByName(name, node);
    if (null != result) {
        return result;
    }
}

或与流

return t.getChildren()
    .map(node -> findNodeByName(name, node))
    .filter(Objects::nonNull)
    .findAny();