Java中的树实现（根、父和子）_Java_Tree_Structure

Java中的树实现（根、父和子）

java tree

Java中的树实现（根、父和子）,java,tree,structure,Java,Tree,Structure,我需要创建一个类似于Java中附加图像的树结构。我发现了一些与此相关的问题，但我还没有找到一个令人信服且解释得很好的答案。应用业务包括食品超级类别（主菜、甜点和其他）。每个类别都可以有父项或子项，依此类推组装树节点的过程与组装列表的过程类似。我们有一个树节点的构造函数来初始化实例变量 public Tree (Object cargo, Tree left, Tree right) { this.cargo = cargo; this.left = left;

我需要创建一个类似于Java中附加图像的树结构。我发现了一些与此相关的问题，但我还没有找到一个令人信服且解释得很好的答案。应用业务包括食品超级类别（主菜、甜点和其他）。每个类别都可以有父项或子项，依此类推

组装树节点的过程与组装列表的过程类似。我们有一个树节点的构造函数来初始化实例变量

public Tree (Object cargo, Tree left, Tree right) { 
    this.cargo = cargo; 
    this.left = left; 
    this.right = right; 
}

我们首先分配子节点：

Tree left = new Tree (new Integer(2), null, null); 
Tree right = new Tree (new Integer(3), null, null);

我们可以创建父节点，同时将其链接到子节点：

Tree tree = new Tree (new Integer(1), left, right);

此树不是二叉树，所以需要一个子元素数组，如List

public Node(Object data, List<Node> children) {
    this.data = data;
    this.children = children;
}

公共节点（对象数据，列表子节点）{
这个数据=数据；
这个。孩子=孩子；
}

然后创建实例。

导入java.util.ArrayList；
import java.util.ArrayList;
import java.util.List;

public class Node<T> {
    private List<Node<T>> children = new ArrayList<Node<T>>();
    private Node<T> parent = null;
    private T data = null;

    public Node(T data) {
        this.data = data;
    }

    public Node(T data, Node<T> parent) {
        this.data = data;
        this.parent = parent;
    }

    public List<Node<T>> getChildren() {
        return children;
    }

    public void setParent(Node<T> parent) {
        parent.addChild(this);
        this.parent = parent;
    }

    public void addChild(T data) {
        Node<T> child = new Node<T>(data);
        child.setParent(this);
        this.children.add(child);
    }

    public void addChild(Node<T> child) {
        child.setParent(this);
        this.children.add(child);
    }

    public T getData() {
        return this.data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public boolean isRoot() {
        return (this.parent == null);
    }

    public boolean isLeaf() {
        return this.children.size == 0;
    }

    public void removeParent() {
        this.parent = null;
    }
}

导入java.util.List；
公共类节点{
private List children=new ArrayList（）；
私有节点父节点=null；
私有T数据=null；
公共节点（T数据）{
这个数据=数据；
}
公共节点（T数据，节点父节点）{
这个数据=数据；
this.parent=parent；
}
公共列表getChildren（）{
返回儿童；
}
公共void setParent（节点父节点）{
parent.addChild（this）；
this.parent=parent；
}
公共void addChild（T数据）{
节点子节点=新节点（数据）；
child.setParent（this）；
this.children.add（child）；
}
公共void addChild（节点子节点）{
child.setParent（this）；
this.children.add（child）；
}
公共T getData（）{
返回此.data；
}
公共无效设置数据（T数据）{
这个数据=数据；
}
公共布尔值isRoot（）{
返回（this.parent==null）；
}
公共布尔isLeaf（）{
返回this.children.size==0；
}
public void removeParent（）{
this.parent=null；
}
}

例如：

import java.util.List;

Node<String> parentNode = new Node<String>("Parent"); 
Node<String> childNode1 = new Node<String>("Child 1", parentNode);
Node<String> childNode2 = new Node<String>("Child 2");     

childNode2.setParent(parentNode); 

Node<String> grandchildNode = new Node<String>("Grandchild of parentNode. Child of childNode1", childNode1); 
List<Node<String>> childrenNodes = parentNode.getChildren();

import java.util.List；
节点父节点=新节点（“父节点”）；
节点childNode1=新节点（“子节点1”，父节点）；
Node childNode2=新节点（“子节点2”）；
childNode2.setParent（parentNode）；
节点孙子节点=新节点（“parentNode的孙子节点。childNode1的子节点”，childNode1）；
List childrenNodes=parentNode.getChildren（）；

在接受的答案中

public Node(T data, Node<T> parent) {
    this.data = data;
    this.parent = parent;
}

公共节点（T数据，节点父节点）{
这个数据=数据；
this.parent=parent；
}

应该是

public Node(T data, Node<T> parent) {
    this.data = data;
    this.setParent(parent);
}

公共节点（T数据，节点父节点）{
这个数据=数据；
这个.setParent（parent）；
}

否则，当调用

setParent

或

addChild

方法时，父对象的子对象列表中没有子对象

下面是一个没有这些bug的稍微简单的实现：

public class MyTreeNode<T>{
    private T data = null;
    private List<MyTreeNode> children = new ArrayList<>();
    private MyTreeNode parent = null;

    public MyTreeNode(T data) {
        this.data = data;
    }

    public void addChild(MyTreeNode child) {
        child.setParent(this);
        this.children.add(child);
    }

    public void addChild(T data) {
        MyTreeNode<T> newChild = new MyTreeNode<>(data);
        this.addChild(newChild);
    }

    public void addChildren(List<MyTreeNode> children) {
        for(MyTreeNode t : children) {
            t.setParent(this);
        }
        this.children.addAll(children);
    }

    public List<MyTreeNode> getChildren() {
        return children;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    private void setParent(MyTreeNode parent) {
        this.parent = parent;
    }

    public MyTreeNode getParent() {
        return parent;
    }
}

公共类MyTreeNode{
私有T数据=null；
private List children=new ArrayList（）；
private MyTreeNode parent=null；
公共MyTreeNode（T数据）{
这个数据=数据；
}
public void addChild（MyTreeNode child）{
child.setParent（this）；
this.children.add（child）；
}
公共void addChild（T数据）{
MyTreeNode newChild=新MyTreeNode（数据）；
这是addChild（newChild）；
}
公共子项（列出子项）{
用于（MyTreeNode t:儿童）{
t、 setParent（本）；
}
this.children.addAll（children）；
}
公共列表getChildren（）{
返回儿童；
}
公共T getData（）{
返回数据；
}
公共无效设置数据（T数据）{
这个数据=数据；
}
私有void setParent（MyTreeNode父级）{
this.parent=parent；
}
公共MyTreeNode getParent（）{
返回父母；
}
}

一些例子：

MyTreeNode<String> root = new MyTreeNode<>("Root");

MyTreeNode<String> child1 = new MyTreeNode<>("Child1");
child1.addChild("Grandchild1");
child1.addChild("Grandchild2");

MyTreeNode<String> child2 = new MyTreeNode<>("Child2");
child2.addChild("Grandchild3");

root.addChild(child1);
root.addChild(child2);
root.addChild("Child3");

root.addChildren(Arrays.asList(
        new MyTreeNode<>("Child4"),
        new MyTreeNode<>("Child5"),
        new MyTreeNode<>("Child6")
));

for(MyTreeNode node : root.getChildren()) {
    System.out.println(node.getData());
}

MyTreeNode root=新的MyTreeNode（“root”）；
MyTreeNode child1=新MyTreeNode（“child1”）；
子女1.添加子女（“孙子女1”）；
子女1.添加子女（“孙子女2”）；
MyTreeNode child2=新MyTreeNode（“child2”）；
子女2.添加子女（“孙子女3”）；
root.addChild（child1）；
root.addChild（child2）；
root.addChild（“Child3”）；
root.addChildren（Arrays.asList(
新MyTreeNode（“Child4”），
新MyTreeNode（“Child5”），
新MyTreeNode（“Child6”）
));
对于（MyTreeNode节点：root.getChildren（））{
System.out.println（node.getData（））；
}

以下是我的java实现，以满足您的需求。在treeNode类中，我使用通用数组来存储树数据。我们还可以使用arraylist或dynamic array来存储树值

public class TreeNode<T> { private T value = null; private TreeNode[] childrens = new TreeNode[100]; private int childCount = 0; TreeNode(T value) { this.value = value; } public TreeNode addChild(T value) { TreeNode newChild = new TreeNode(value, this); childrens[childCount++] = newChild; return newChild; } static void traverse(TreeNode obj) { if (obj != null) { for (int i = 0; i < obj.childCount; i++) { System.out.println(obj.childrens[i].value); traverse(obj.childrens[i]); } } return; } void printTree(TreeNode obj) { System.out.println(obj.value); traverse(obj); } }
输出

Menu Starter Veg Paneer Tikka Malai Paneer Tikka Non-veg Chicken Tikka Malai Chicken Tikka Main Course Veg Mili Juli Sabzi Aloo Shimla Mirch Non-veg Chicken Do Pyaaza Chicken Chettinad Desserts Cakes Black Forest Black Current Ice Creams chocolate Vanilla
在，它会创建循环依赖关系。可以通过删除子节点中的父节点来避免这种情况。 i、 e

公共类MyTreeNode{ 私有T数据=null； private List children=new ArrayList（）；公共MyTreeNode（T数据）{ 这个数据=数据； } public void addChild（MyTreeNode child）{ this.children.add（child）； } 公共void addChild（T数据）{ MyTreeNode newChild=新MyTreeNode（数据）；添加（newChild）； } 公共子项（列出子项）{ this.children.addAll（children）； } 公共列表getChildren（）{ 返回儿童； } 公共T getData（）{ 返回数据； } 公共无效设置数据（T数据）{ 这个数据=数据； } }
使用上面指定的相同示例，输出如下：
{“数据”：“根”，“子项”：[ { “数据”：“Child1”， “儿童”：[ { “数据”：“1”， “儿童”：[] }, { “数据”：“2”， “儿童”：[] } ] }, { “数据”：“Child2”， “儿童”：[ { “数据”：“3”，
Menu Starter Veg Paneer Tikka Malai Paneer Tikka Non-veg Chicken Tikka Malai Chicken Tikka Main Course Veg Mili Juli Sabzi Aloo Shimla Mirch Non-veg Chicken Do Pyaaza Chicken Chettinad Desserts Cakes Black Forest Black Current Ice Creams chocolate Vanilla

public class MyTreeNode<T>{ private T data = null; private List<MyTreeNode> children = new ArrayList<>(); public MyTreeNode(T data) { this.data = data; } public void addChild(MyTreeNode child) { this.children.add(child); } public void addChild(T data) { MyTreeNode<T> newChild = new MyTreeNode<>(data); children.add(newChild); } public void addChildren(List<MyTreeNode> children) { this.children.addAll(children); } public List<MyTreeNode> getChildren() { return children; } public T getData() { return data; } public void setData(T data) { this.data = data; } }