grafico - Implementación de árbol en Java(root, padres e hijos)

codigo arbol de expresiones en java

Question

Necesito crear una estructura de árbol similar a la imagen adjunta en Java. He encontrado algunas preguntas relacionadas con esta, pero no he encontrado una respuesta convincente y bien explicada. El negocio de aplicación consiste en súper categorías de comida (platos principales, postres y otros). Cada una de estas categorías puede tener elementos principales o elementos secundarios, etc.

Answer 1

Aquí está mi implementación en java para su requerimiento. En la clase treeNode usé una matriz genérica para almacenar los datos del árbol. También podemos usar arraylist o array dinámico para almacenar el valor del árbol.

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

Y la clase cliente para la implementación anterior.

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

SALIDA

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 

Answer 2

El proceso de ensamblar nodos de árbol es similar al proceso de ensamblar listas. Tenemos un constructor para nodos de árbol que inicializa las variables de instancia.

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

Primero asignamos los nodos secundarios:

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

Podemos crear el nodo padre y vincularlo a los hijos al mismo tiempo:

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

Answer 3

En answer , crea una dependencia circular. Esto puede evitarse eliminando el elemento primario dentro de los nodos secundarios. es decir,

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

Usando el mismo ejemplo especificado anteriormente, la salida será así:

{"data": "Root", "children": [{"data": "Child1", "children": [{"data": "Grandchild1", "children": []}, {"data": "Grandchild2", "children": []}]}, {"data": "Child2", "children": [{"data": "Grandchild3", "children": []}]}, {"data ":" Child3 "," children ": []}, {" data ":" Child4 "," children ": []}, {" data ":" Child5 "," children ": []}, {" datos ":" Child6 "," niños ": []}]}

Answer 4

En la respuesta aceptada

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

debiera ser

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

De lo contrario, el padre no tiene al niño en su lista de hijos.

Answer 5

Este árbol no es un árbol binario, por lo que necesita una matriz de elementos secundarios, como Lista.

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

Luego crea las instancias.

Answer 6

La respuesta aceptada lanza un java.lang.Error al llamar a los métodos setParent o addChild .

Aquí hay una implementación un poco más simple sin esos errores:

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

Algunos ejemplos:

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

Answer 7

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

Ejemplo:

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