Percorrer arvore raizada (grafo)

public void verNodosPreOrdem(Arvore<E> arvore){
        
        /**
         *visito a raíz 
         */
        System.out.println("\t"+arvore.elemento.toString());
        
        if (arvore.getGrau()!=0){
            /**
             * Se tiver percorre sua lista de filhos chamando a
             * recursão:
             */
            for (Arvore<E> a: arvore.filhos){
                verNodosPreOrdem(a);
            }
        
        }
        
    }

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * Árvore geral implementada de forma recursiva.
 * Cada objeto representa um nodo da árvore que
 * pode possuir um número qualquer de nodos filhos (também chamados de subárvores).
 * @param <E> o tipo de objeto armazenado nos nodo da árvore
 */
public class Arvore<E> implements Iterable<E>{
	//Chama o método Arvore e passa pra ele
    private Arvore<E> pai;
	private E elemento;
	private List<Arvore<E>> filhos;
    //novo método que informa se a arvore já foi visitada ou não;
	private boolean visitada = false;
    
    
	/**
	 * Constrói uma árvore com um único nodo.
	 * @param item objeto armazenado no nodo da árvore (ancestral de todos os outros nodos)
	 */
	public Arvore(E item) {
		pai = null;
		elemento = item;
		filhos = new LinkedList<Arvore<E>>();
	}
    
    
    public boolean getVisitada(){
        return visitada;
    }
    
    public void setVisitada(boolean v){
        visitada = v;
    }
    
	
	/**
	 * Retorna o número de nodos da árvore.
	 * @return o número de nodos da árvore
	 */
	public int tamanho() {
		int cont = 1;
        for(Arvore<E> a : filhos)
            cont += a.tamanho();
        return cont;
	}
	
	/**
	 * Retorna o objeto armazenado no nodo da árvore.
	 * @return o objeto armazenado no nodo da árvore (uma pessoa)
	 */
	public E getItem() {
		return elemento;
	}
	
	/**
	 * Altera o objeto armazenado no nodo da árvore.
	 * @param item o objeto a ser armazenado no nodo da árvore
	 */
	public void setItem(E item) {
		elemento = item;
	}
	
	/**
	 * Retorna o nodo pai do nodo. 
	 * @return o nodo pai do nodo com sua LinkedList de filhos
	 */
	public Arvore<E> getPai() {
		return pai;
	}
	
	/**
	 * Retorna o grau da árvore (o número de filhos do nodo).
	 * @return o grau da árvore
	 */
	public int getGrau() {
		return filhos.size();
	}
	
	/**
	 * Retorna a i-ésima subárvore.
	 * @param indice da i-ésima subárvore
	 * @return a i-ésima subárvore
	 */
	public Arvore<E> getSubarvore(int indice) {
		if((indice<0) || (indice>=getGrau()))
            throw new IndexOutOfBoundsException();
        return filhos.get(indice);
	}
	
	/**
	 * Anexar uma subárvore.
	 * @param arvore a ser anexada
	 */
	public void anexarSubarvore(Arvore<E> arvore) {
		arvore.pai = this;
		filhos.add(arvore);//vai anexando subarvores
	}
    
    /**
     * Método verNosPreOrdem.
     *
     * @param arvore
     * 
     * @see algoritmo que recebe uma arvore
     * e retorna seus filhos com uma pré-ordem
     * pela árvore.
     *   
     * @since JDK1.4.2
     * 
     * Autor rafaelsm, em 08/05/2007.
     */
    public void verNodosPreOrdem(Arvore<E> arvore){
        
        /**
         *visito a raíz 
         */
        System.out.println("\t"+arvore.elemento.toString());
        
        if (arvore.getGrau()!=0){
            /**
             * Se tiver percorre sua lista de filhos chamando a
             * recursão:
             */
            for (Arvore<E> a: arvore.filhos){
                verNodosPreOrdem(a);
            }
        
        }
        
    }
    
    
    
    /**
     * Método verNodosOrdem.
     *
     * @param arvore
     * 
     * @see Imprime os Nodos da arvore de forma ordenada simetricamente
     *   
     * @since JDK1.4.2
     * 
     * Autor rafaelsm, em 09/05/2007.
     */
    public void verNodosOrdem(Arvore<E> arvore){
        
        //se não tem um pai...
        
        //percorro sua lista de filhos e imprimo eles
        for (Arvore<E> a: arvore.filhos){
            
            //verifico se o pai ja foi visitado... se já tiver
            //sido, nao o imprimo caso contrario marco ele como 
            //visitado e imprimo ele:
            if(a.getPai().getVisitada()==false){
                System.out.println(a.getPai().elemento.toString());
                a.getPai().setVisitada(true);
            }
            //independente imprimo seus filhos:
            verNodosOrdem(a);
            
            if (a.getVisitada()==false){
                System.out.println(a.elemento.toString());
            }
           
            
        }
        
        
        
        
    }
    
    
    /**
     * Método accept.
     *
     * @param c
     * 
     * @see recebe uma arvore c, não tenho nem ideia 
     * do que serve. Parece que recebe um visitante
     * e tipo aceita 
     *   
     * @since JDK1.4.2
     * 
     * Autor rafaelsm, em 08/05/2007.
     */
    public void accept(Visitor c){
        
        c.visiteArvore(this);
        
    }


    public Iterator<E> iterator() {
        return null;
    }

}