Java.lang.StackOverflowError ao rodar algoritmo de componentes conexas em um grafo Hashtable

Programação Java
#1

Fala, pessoal!

 Escrevi o algoritmo para encontrar as componentes conexas de um grafo, mas, quando executo a partir de um grafo muito grande, é gerada a exceção de estouro de pilha. Ela acontece exatamente na primeira linha da função visiterVoisins, mas não entendo a causa.
 O código das funções envolvidas segue a abaixo. Agradeço desde já se alguém puder ajudar.
 Desculpem-me pela identação, mas não consegui fazê-la neste editor do forum.

 Abraços!

 -----

private void initComposantes(Enumeration<Integer> keys, Hashtable<Integer, Sommet> sommets)
{
Integer keySommetActuel;
Sommet sommetActuel;

	while(keys.hasMoreElements()) // pour tous les sommets
	{
		keySommetActuel = keys.nextElement();
		sommetActuel    = sommets.get(keySommetActuel);
		
		sommetActuel.setComposanteConnexe(-1);
	}    	    	
}

/*
 * Pour chaque sommet, visite la liste de ses voisins pour marquer que il est dans
 * la meme composante connexe
 */
private void visiterVoisins(Hashtable&lt;Integer, Sommet&gt; sommets, int keySommetActuel, int composante)
{

Sommet sommetActuel = sommets.get(keySommetActuel); // A exceção é lançada aqui!
Vector<Successeur> voisins = sommetActuel.getSucc();
Successeur succ;

	int numeroVoisin;
	
	sommetActuel.setComposanteConnexe(composante);
	
	Iterator&lt;Successeur&gt; it = voisins.iterator();
	
	while(it.hasNext())
	{
		succ = it.next();
		numeroVoisin = succ.getNumero(); // prend la cle du voisin actuel
		
		// Si le voisin actuel n'a pas encore ete visite
		if(sommets.get(numeroVoisin).getComposanteConnexe() == -1)    		
			visiterVoisins(sommets, numeroVoisin, composante);
	}		    			
}

/* 
 * Calcul des composantes connexes du graphe
 */
public void connexite (PrintStream sortie, Graphe graphe, boolean display) 
{    	
	Hashtable&lt;Integer, Sommet&gt; sommets = graphe.getGraphe();
	Enumeration&lt;Integer&gt;       keys    = sommets.keys();
	Sommet					   sommetActuel;
	
	int keySommetActuel;
	int composanteActuelle = 0;
	String chaine = new String();

	sortie.println("** Composante connnexe de chaque sommet");
	
    this.initComposantes(keys, sommets); // marque tous les sommets avec -1
	
    keys = sommets.keys(); // recommence l'enumeration
    
    while(keys.hasMoreElements())
    {
    	keySommetActuel = keys.nextElement();
    	sommetActuel    = sommets.get(keySommetActuel);
    	
    	// si le sommet n'a pas encore ete visite
    	if(sommetActuel.getComposanteConnexe() == -1)
    		// met ses voisins dans la meme composante
    		visiterVoisins(sommets, keySommetActuel, ++composanteActuelle);
    	
    	chaine = "\n" + keySommetActuel + " " + composanteActuelle + chaine;
    }
    
	sortie.println(composanteActuelle + "\n" + chaine);
    sortie.close();
}

 -----
#2

Usa a tag code no no seu post

Seu algoritmo está em ciclo, tem uma parte do seu código que tem chamada recursiva na linha 24, debuga e verifica se o ciclo e da próxima vez usa a tag code.

/*
* Pour chaque sommet, visite la liste de ses voisins pour marquer que il est dans
* la meme composante connexe
*/
private void visiterVoisins(Hashtable<Integer, Sommet> sommets, int keySommetActuel, int composante)
{
    Sommet sommetActuel = sommets.get(keySommetActuel); // A exceção é lançada aqui!
    Vector<Successeur> voisins = sommetActuel.getSucc();
    Successeur succ;

    int numeroVoisin;

    sommetActuel.setComposanteConnexe(composante);

    Iterator<Successeur> it = voisins.iterator();

    while(it.hasNext())
    {
        succ = it.next();
        numeroVoisin = succ.getNumero(); // prend la cle du voisin actuel

        // Si le voisin actuel n'a pas encore ete visite
        if(sommets.get(numeroVoisin).getComposanteConnexe() == -1)
            visiterVoisins(sommets, numeroVoisin, composante);
    }
}
#3

Se o seu grafo for realmente muito grande, pode ser que nem seja problema de o seu programa estar em ciclo.
Pode ser que a pilha de chamadas do Java é que seja pequena para o seu grafo.
O Java ‘descobre’ que um programa está em ciclo quando o número de chamadas a funções estoura.
Para aumentar este número(no Windows é 256K) basta vc adicionar o seguinte, na sua linha de comando:
-Xss

É identico a definir a quantidade de memória da sua aplicação.

#4

[quote=clone_zealot]Se o seu grafo for realmente muito grande, pode ser que nem seja problema de o seu programa estar em ciclo.
Pode ser que a pilha de chamadas do Java é que seja pequena para o seu grafo.
O Java ‘descobre’ que um programa está em ciclo quando o número de chamadas a funções estoura.
Para aumentar este número(no Windows é 256K) basta vc adicionar o seguinte, na sua linha de comando:
-Xss

É identico a definir a quantidade de memória da sua aplicação.[/quote]

Cuidado que -Xss não aumenta o tamanho da pilha da thread principal do seu programa (a que é implicitamente usada pelo “main”). Crie uma outra thread e execute essa chamada em uma outra thread.

#5