Aide Java LinkedTree - java

J'essaie d'implémenter un arbre lié, mais je reçois une exception nullpointer lorsque je l'exécute. Pouvez-vous m'aider à arranger ça?

Exception dans le fil "main" java.lang.NullPointerException à assign2Trees.LinkedTree.size (LinkedTree.java:16) à assign2Trees.LinkedTree.main (LinkedTree.java:80)
import java.util.Iterator;
import java.util.NoSuchElementException;

public class LinkedTree<E> implements Tree<E>{

private Node<E> root;

public LinkedTree()
{
super();
}
public int size()
{
return root.getChildren().size() + 1;
}
public boolean isEmpty()
{
if(root == null)
return true;
else
return false;
}
public Iterator<E> iterator()
{
return new Iterator<E>()
{
private int i = 0;

public boolean hasNext()
{
return i < LinkedTree.this.size();
}
public E next() throws NoSuchElementException
{
if (!hasNext())
{
return null;
}
return (E) LinkedTree.this.root.getChildren().get(i++);
}
public void remove()
{

}
};
}
public E replace(E oldE, E newE)
{
int i = root.getChildren().indexOf(oldE);
root.getChildren().add(i, (Node<E>) newE);
return newE;
}
public E root() throws EmptyTreeException
{
if (isEmpty())
throw new EmptyTreeException ();
return this.root();
}
public E parent(E node)
{
return (E) ((Node<E>) root.getChildren()).getParent((root.getChildren().get(root.getChildren().indexOf(node))));
}
public Iterable<E> children(E node)
{
return (Iterable<E>) root.getChildren().listIterator();
}
public void delete(E node) throws RootNonDeletableException
{
if (node == null)
throw new RootNonDeletableException();
else
root.getChildren().remove(root.getChildren().indexOf(node));
}

public static void main(String[] args)
{
LinkedTree<Node<String>> tree = new LinkedTree<Node<String>>();
System.out.println(tree.size());

}


}


import java.util.ArrayList;
import java.util.List;

public class Node<E>{

protected E contents;
protected List<Node<E>> children;
protected Node<E> parent;

public Node()
{
super();
}
public Node(E contents)
{
this.setContents(contents);
}
public List<Node<E>> getChildren()
{
if(this.children == null)
{
return new ArrayList<Node<E>>();
}
return this.children;
}
public void setChildren(List<Node<E>> children)
{
this.children = children;
}
public void addChild(Node<E> child)
{
if (children == null)
{
children = new ArrayList<Node<E>>();
}
children.add(child);
}
public E getContents()
{
return this.contents;
}
public void setContents(E contents)
{
this.contents = contents;
}
public Node<E> getParent(Node<E> node)
{
return node.parent;
}
public void setParent(Node<E> parent, Node<E> child)
{
child.parent = parent;
}
}

Réponses:

2 pour la réponse № 1

root est nul. Vous n'êtes pas en train d'initialiser root à rien ou en vérifiant que ce n'est pas nul avant d'y accéder sur cette ligne:

return root.getChildren().size() + 1;

Peut-être:

return (root == null) ? 0 : root.getChildren().size()+1;

Donc, plus que probablement, ce que vous devez vraiment faire est de définir root à un nouveau nœud dans votre constructeur, par exemple:

public LinkedTree()
{
super();
root = new Node<E>();
}

Vous avez aussi une erreur avec votre root() fonction:

public E root() throws Exception
{
if (isEmpty())
throw new Exception ();
return this.root();
}

S'appellera. Peut-être que vous vouliez dire

public E root() throws Exception
{
if (isEmpty())
throw new Exception ();
return this.root;
}

Maintenant, pour commencer à construire votre arbre dans votre méthode principale, vous pouvez faire quelque chose comme:

tree.root().addChild(new Node<String>("test"));

Cela permet d'obtenir la racine de l'arbre, puis d'y ajouter un enfant.

Supposons que vous vouliez ajouter une structure compliquée, par exemple un nœud avec un enfant, vous pourriez faire:

Node<String> deepest = new Node<String>("deepest node");
Node<String> deeper  = new Node<String>("deeper node");
deeper.addChild(deepest);
tree.root().addChild(deeper);

Cela vous donne un arbre avec une structure:

[racine] + - [plus profond] + - plus profond

0 pour la réponse № 2

Changement

public List<Node<E>> getChildren()
{
if(this.children == null)
{
return new ArrayList<Node<E>>();
}
return this.children;
}

à

public List<Node<E>> getChildren()
{
if(this.children == null)
{
return this.children = new ArrayList<Node<E>>(); // set the this.children field and return.
}
return this.children;
}

Dis-moi comment ça se passe.


0 pour la réponse № 3

Le noeud racine n’est jamais initialisé. Vous essayez donc d’appeler getChildren () sur un objet qui n’existe pas.