Árbol del nodo <T> explicación

Question

No sé si estoy autorizado a hacerlo de acuerdo con las reglas del sitio ... pero me arriesgaré ... por favor tengan paciencia, solo soy un estudiante .. . :-)

Tengo una tarea en la universidad ... Tengo dificultades para entender lo que las clases deberían hacer ... He ido a ver a mi maestro en tres ocasiones diferentes y la respuesta que obtuve de él no ayuda en absoluto. 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 (Nodo padre, niño nodo) {} - Añade un nuevo nodo secundario al nodo padre

pública removeChild vacío (Nodeparent, hijo del nodo) {} - Elimina un nodo secundario de un padre.

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

pública setRoot vacío (nodo raíz) {} - Establece el nodo raíz del árbol

public boolean contiene (datos T) {} - busca el árbol para un tipo dado

DFS public void (hijo del nodo) {} - Realiza una profundidad de primera busca del tre E y da salida a cada nodo (sangría)

BFS public void (hijo del nodo) {} - Realiza una amplitud de primera busca del árbol y da salida a cada nodo (sangría)

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

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

Ahora he escrito mi clase Node que funciona bien ... y para ser honesto, 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. Estoy NO buscando el código en sí ... solo quiero entender lo que se supone que debo hacer.

Mi Nodo Clase

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

Se utiliza el mapa de lo siguiente:

La clave del mapa hash es un nodo dado, y el valor de la HashMap son los nodos secundarios para el dado nodo.

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 aclarar cómo funciona el árbol?

Answer 2

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

El árbol en sí se puede parametrizar. 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 esta 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

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.

Dado que no parece que se supone que debe hacer esto, puede hacer que Tree<T> sea una clase contenedora que hace referencia a un solo objeto Node<T>. Puede poner la lógica para los métodos requeridos en cualquier clase.

El principio del código podría ser algo como esto:

public class Tree<T> { 

    private Node<T> root; 

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

}