java - library - La explicación de Tree of Node<T>

tree java api

Question

No sé si se me permite hacer esto de acuerdo con las reglas del sitio ... pero me arriesgaré ... por favor tengan paciencia, solo soy un estudiante ... :-)

Tengo una tarea en la universidad ... Me cuesta entender lo que las clases deberían hacer ... He asistido a mi maestra en tres ocasiones diferentes y la respuesta que obtuve de él no me ayudó para nada. De todos modos, los detalles de la asignación son los siguientes ...

Crea una clase llamada Tree que actúa como un contenedor para nodos. La clase de árbol debe ser compatible con los siguientes métodos.

public void add (Node parent, Node child) {} - Agrega un nuevo nodo secundario al nodo padre

public void removeChild (Nodeparent, Node child) {} - Elimina un nodo secundario de un padre.

nodo público getRootNode () {} - Devuelve la raíz del árbol

public void setRoot (raíz del nodo) {} - Establece el nodo raíz del árbol

public boolean contains (T data) {} - Busca en el árbol un tipo dado

public void dfs (Node child) {} - Realiza una búsqueda en profundidad del árbol y genera cada nodo (sangrado)

public void bfs (Node child) {} - Realiza una búsqueda de ancho de banda en el árbol y saca cada nodo (sangrado)

1. La clase de árbol debe estar parametrizada para manejar un tipo genérico T, que permite crear árboles de cadenas, archivos, etc ..., por ejemplo, Tree<String> tree = new Tree<String>()
2. La clase de árbol debe implementar la estructura de árbol usando una lista de adyacencia y definirse de la siguiente manera: Map<Node<T>, List<Node<T>>> tree = new HashMap<Node<T>, List<Node<T>>();

La clase de nodo también debe estar parametrizada para manejar un tipo genérico T y exponer varios métodos ...

Ahora escribí mi clase Node que funciona bien ... y para ser sincero, estaba seguro de haber escrito una clase Node que está creando un árbol. pero después de leer la descripción de la clase Tree estoy confundido. Lo que debería almacenar en el árbol Mapa. Estoy teniendo dificultades para visualizar todo.

Quizás alguien pueda explicar lo que quiere el maestro y ponerme en la dirección correcta. No estoy buscando el código en sí ... solo quiero entender lo que se supone que debo hacer.

Mi clase de nodo

public class Node<T>
{
private Node<T> root; // a T type variable to store the root of the list
private Node<T> parent; // a T type variable to store the parent of the list
private T child;
private List<Node<T>> children = new ArrayList<Node<T>>(); // a T type list to store the children of the list
// default constructor
public Node(T child)
{
setParent(null);
setRoot(null);
setItem(child);
}
// constructor overloading to set the parent
public Node(Node<T> parent)
{
this.setParent(parent);
//this.addChild(parent);
}
// constructor overloading to set the parent of the list
public Node(Node<T> parent, Node<T> child)
{
this(parent);
this.children.add(child);
}
/**
* This method doesn''t return anything and takes a parameter of
* the object type you are trying to store in the node
*
* @param Obj an object
* @param
**/
public void addChild(Node<T> child)
{
child.root = null;
child.setParent((Node<T>)this);
this.children.add(child); // add this child to the list
}
public void removeChild(Node<T> child)
{
this.children.remove(child); // remove this child from the list
}
public Node<T> getRoot() {
return root;
}
public boolean isRoot()
{
// check to see if the root is null if yes then return true else return false
return this.root != null;
}
public void setRoot(Node<T> root) {
this.root = root;
}
public Node<T> getParent() {
return parent;
}
public void setParent(Node<T> parent) {
this.parent = parent;
}
public T getItem() {
return child;
}
public void setItem(T child) {
this.child = child;
}
public boolean hasChildren()
{
return this.children.size()>0;
}
@SuppressWarnings("unchecked")
public Node<T>[] children()
{
return (Node<T>[]) children.toArray(new Node[children.size()]);
}
@SuppressWarnings({ "unchecked"})
public Node<T>[] getSiblings()
{
if(this.isRoot()!=false && parent==null)
{
System.out.println("this is root or there are no siblings");
return null;
}
else{
List<Node<T>> siblings = new ArrayList<Node<T>>((Collection<? extends Node<T>>) Arrays.asList(new Node[this.parent.children.size()]));
Collections.copy(siblings, this.parent.children);
siblings.remove(this);
return siblings.toArray(new Node[siblings.size()]);
}
}
}

Answer 1

Esto es un poco extraño Si estuviera haciendo esto y la tarea no dijera lo contrario, probablemente no escribiría una clase Tree en absoluto; Solo usaría Node como una estructura recursiva de datos, y haría que el nodo raíz de un árbol representara todo el árbol.

Como no parece que se supone que debes hacer esto, podrías hacer que Tree<T> una clase contenedora que tenga una referencia a un solo objeto Node<T> . Puede poner la lógica para los métodos requeridos en cualquier clase.

El comienzo del código podría verse más o menos así:

public class Tree<T> {
private Node<T> root;
public Tree(Node<T> root) {
this.root = root;
}
}

Answer 2

Mirando los 2 puntos en la lista, voy a adivinar que el punto número 1 es el más confuso para ti.

El árbol en sí puede ser parametrizado. El parámetro tipo en la clase de árbol se puede usar dentro de una clase interna que se usa para crear los nodos. Es decir, para los propósitos de su asignación, la clase de nodo probablemente debería estar dentro de la clase de árbol para que pueda usar el parámetro de tipo T dado a la clase de árbol.

De esa forma, el árbol puede almacenar cualquier cosa (cadenas, archivos, dobles, etc.). La clase Node simplemente actúa como una buena forma de almacenar cualquier objeto tipo T.

Answer 3

Usas el mapa para lo siguiente:

La clave del hashmap es un nodo dado, y el valor del hashmap son los nodos secundarios para el nodo dado.

public class Tree<T> {
private Node<T> rootNode;
private HashMap<Node<T>, List<Node<T>> tree;
//and then some kind of function to go through the tree.
public void expandNode(Node<T> node) {
if (tree.get(node) == null) {
System.out.println(node);
return;
}
for(Node<T> n : tree.get(node)) {
System.out.println(node);
expandNode(n);
}
}
}

¿Podría dejar en claro cómo funciona el árbol?