L'arbre de la mise en œuvre en Java (racine, les parents et les enfants)

J'ai besoin de créer une arborescence de structure similaire comme l'image jointe en Java. J'ai trouvé certaines questions liées à celle-ci mais je n'ai pas trouvé de convaincant et bien expliqué réponse.
L'application se compose d'affaires dans les aliments super catégories (plats principaux, desserts et autres). Chacune de ces catégories peuvent avoir des éléments parents ou les enfants et ainsi de suite.

InformationsquelleAutor Carlos | 2013-10-12

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;
}
}

Exemple:

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();

c'est bon, avez-vous des exemples de comment utiliser les fonctions d'arbre?
Node<String> parentNode = new Node<String>("Parent"); \r
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();
java.lang.StackOverflowError à l'arbre.Nœud.addChild(Nœud.java:40) de l'arbre.Nœud.setParent(Nœud.java:29) à l'arbre.Nœud.addChild(Nœud.java:40) de l'arbre.Nœud.setParent(Nœud.java:29) à l'arbre.Nœud.addChild(Nœud.java:40) de l'arbre.Nœud.setParent(Nœud.java:29) à l'arbre.Nœud.addChild(Nœud.java:40) de l'arbre.Nœud.setParent(Nœud.java:29) à l'arbre.Nœud.addChild(Nœud.java:40) de l'arbre.Nœud.setParent(Nœud.java:29) à l'arbre.Nœud.addChild(Nœud.java:40) de l'arbre.Nœud.setParent(Nœud.java:29)
Devrait-il y avoir un equals et hashCode méthode?
vérifier ma réponse.

InformationsquelleAutor Jonathan

Accepté de répondre à jette un java.lang.StackOverflowError lors de l'appel de la setParent ou addChild méthodes.

Ici est un peu plus simple de mise en œuvre sans ces bugs:

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;
}
}

Quelques exemples:

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());
}

Cette conception souffre de dépendance circulaire et la mutabilité. Résoluble par nixing le parent et le mettre dans une carte distincte de nœuds pour les parents si nécessaire.

InformationsquelleAutor Esdras Lopez

Dans la accepté de répondre à

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

devrait être

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

sinon, le parent n'a pas l'enfant dans sa liste d'enfants

S'il vous plaît ajouter un commentaire

InformationsquelleAutor tognyx

Voici mon implémentation en java pour votre condition.
Dans la classe treeNode j'ai utilisé generic array pour stocker l'arbre de données. nous pouvons également utiliser arraylist ou tableau dynamique pour stocker la valeur de cette arborescence.

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);
}
}

Et la classe client pour la mise en œuvre.

public class Client {
public static void main(String[] args) {
TreeNode menu = new TreeNode("Menu");
TreeNode item = menu.addChild("Starter");
item = item.addChild("Veg");
item.addChild("Paneer Tikka");
item.addChild("Malai Paneer Tikka");
item = item.addChild("Non-veg");
item.addChild("Chicken Tikka");
item.addChild("Malai Chicken Tikka");
item = menu.addChild("Main Course");
item = item.addChild("Veg");
item.addChild("Mili Juli Sabzi");
item.addChild("Aloo Shimla Mirch");
item = item.addChild("Non-veg");
item.addChild("Chicken Do Pyaaza");
item.addChild("Chicken Chettinad");
item = menu.addChild("Desserts");
item = item.addChild("Cakes");
item.addChild("Black Forest");
item.addChild("Black Current");
item = item.addChild("Ice Creams");
item.addChild("chocolate");
item.addChild("Vanilla");
menu.printTree(menu);
}
}

SORTIE

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

InformationsquelleAutor Irshad ck

0

Cet arbre n'est pas un arbre binaire, donc vous avez besoin d'un tableau de la les enfants les éléments, comme la Liste.
```
public Node(Object data, List<Node> children) {
this.data = data;
this.children = children;
}
```
Puis créer les instances.

InformationsquelleAutor galovics
0

Dans réponse
il crée de la dépendance circulaire.Ceci peut être évité par la suppression des parents à l'intérieur des nœuds Enfants.
j'.e,
```
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;
}
}
```
En utilisant le même exemple donné ci-dessus,la sortie sera comme ceci:

{ "données": "Root", "children": [
{
"données": "Enfant1",
"les enfants": [
{
"données": "Grandchild1",
"les enfants": []
},
{
"données": "Grandchild2",
"les enfants": []
}
]
},
{
"données": "Enfant2",
"les enfants": [
{
"données": "Grandchild3",
"les enfants": []
}
]
},
{
"données": "Enfant3",
"les enfants": []
},
{
"données": "Child4",
"les enfants": []
},
{
"données": "Child5",
"les enfants": []
},
{
"données": "Child6",
"les enfants": []
} ] }

InformationsquelleAutor Jeevana
-2

Le processus d'assemblage de nœuds de l'arborescence est similaire au processus de constitution des listes. Nous avons un constructeur de nœuds de l'arborescence qui initialise les variables d'instance.
```
public Tree (Object cargo, Tree left, Tree right) { 
this.cargo = cargo; 
this.left = left; 
this.right = right; 
} 
```
Nous répartir les nœuds enfants d'abord:
```
Tree left = new Tree (new Integer(2), null, null); 
Tree right = new Tree (new Integer(3), null, null); 
```
Nous pouvons créer le nœud parent et le lier aux enfants en même temps:
```
Tree tree = new Tree (new Integer(1), left, right); 
```
- Ci-dessus fig n'est pas un arbre binaire.
InformationsquelleAutor Stephen Hosea

Vous devez vous connecter pour publier un commentaire.