Bien donc je suis parti du principe que tu voulais un arbre
binaire d'expression mathématique avec le plus de noeuds
droit possible par niveau, ce qui revient a dire selon moi
que tu cherches a équilibrer ton arbre.

J'ai donc pour l'occasion codé qq chose qui peut répondre à ton
problème, je n'ai pas détaillé ma pensée mais si tu le souhaites
je t'aiderais.

Voici le code :

import java.io.*;
import java.util.regex.*;

public class MyTree
{
	String[] mathExpr;
	MyNode rootNode;
	
	public MyTree(String[] mathExpr_arg)
	{
		mathExpr = mathExpr_arg;
		rootNode = new MyNode();
	}
	
	public void ParcoursMyTreeForAff(MyNode currentNode, int niveau)
	{
		System.out.println("Noeud de niveau : " + niveau + " data : "+ currentNode.data);
		
		if (currentNode.leftChildNode != null)
		{
			ParcoursMyTreeForAff(currentNode.leftChildNode, (niveau + 1));
		}
		
		if (currentNode.rightChildNode != null)
		{
			ParcoursMyTreeForAff(currentNode.rightChildNode, (niveau + 1));
		}
	}
	
	public void FillMyTree(String[] datasToLeft, String[] datasToRight, String data, MyNode currentNode)
	{
		currentNode.data = data;
		
		if (datasToLeft.length > 1)
		{
			currentNode.leftChildNode = new MyNode();
			currentNode.parentNode = currentNode;
			FillMyTree(CutMathExprInTwo(datasToLeft)[0], CutMathExprInTwo(datasToLeft)[1], CutMathExprInTwo(datasToLeft)[2][0], currentNode.leftChildNode);
		}
		if (datasToRight.length > 1)
		{
			currentNode.rightChildNode = new MyNode();
			currentNode.parentNode = currentNode;
			FillMyTree(CutMathExprInTwo(datasToRight)[0], CutMathExprInTwo(datasToRight)[1], CutMathExprInTwo(datasToRight)[2][0], currentNode.rightChildNode);
		}
		if (datasToLeft.length == 1)
		{
			currentNode.leftChildNode = new MyNode();
			currentNode.parentNode = currentNode;
			currentNode.leftChildNode.data = datasToLeft[0];
		}
		if (datasToRight.length == 1)
		{
			currentNode.rightChildNode = new MyNode();
			currentNode.parentNode = currentNode;
			currentNode.rightChildNode.data = datasToRight[0];
		}
	}
	
	public String[][] CutMathExprInTwo(String[] mathExprCurrent)
	{
		String[][] myDecoupage = new String[3][];
		
		//System.out.println("" + (mathExprCurrent.length / 2));
		
		if (!mathExprCurrent[mathExprCurrent.length / 2].matches("[0-9]+"))
		{
			myDecoupage[0] = new String[mathExprCurrent.length / 2];
			myDecoupage[1] = new String[mathExprCurrent.length / 2];
			myDecoupage[2] = new String[1];
			
			for (int i = 0; i < mathExprCurrent.length; i++)
			{
				if (i < mathExprCurrent.length / 2)
				{
					myDecoupage[0][i] = mathExprCurrent[i];
				}
				if (i > mathExprCurrent.length / 2)
				{
					myDecoupage[1][i - (mathExprCurrent.length / 2) - 1] = mathExprCurrent[i];
				}
				myDecoupage[2][0] = mathExprCurrent[(mathExprCurrent.length / 2)];
			}
		}
		if (mathExprCurrent[mathExprCurrent.length / 2].matches("[0-9]+"))
		{
			myDecoupage[0] = new String[(mathExprCurrent.length / 2) + 1];
			myDecoupage[1] = new String[(mathExprCurrent.length / 2) - 1];
			myDecoupage[2] = new String[1];
		
			for (int i = 0; i < mathExprCurrent.length; i++)
			{
				if (i < (mathExprCurrent.length / 2) + 1)
				{
					myDecoupage[0][i] = mathExprCurrent[i];
				}
				if (i > (mathExprCurrent.length / 2) + 1)
				{
					myDecoupage[1][i - (mathExprCurrent.length / 2) - 2] = mathExprCurrent[i];
				}
				myDecoupage[2][0] = mathExprCurrent[(mathExprCurrent.length / 2) + 1];
			}
		}
		
		return myDecoupage;
	}
	
	public void AffTab2D(String[][] tab2D)
	{
		for (int i = 0; i < tab2D.length; i++)
		{	
			for (int j = 0; j < tab2D[i].length; j++)
			{
				System.out.print(tab2D[i][j] + " ");
			}
		
			System.out.println("");
		}
	}
	
	public static void main(String[] args)
	{
		String[] test = new String[7];
		test[0] = "0";
		test[1] = "+";
		test[2] = "1";
		test[3] = "-";
		test[4] = "2";
		test[5] = "+";
		test[6] = "2";
		
		MyTree newTree = new MyTree(test); 
		newTree.FillMyTree(newTree.CutMathExprInTwo(test)[0], newTree.CutMathExprInTwo(test)[1], newTree.CutMathExprInTwo(test)[2][0], newTree.rootNode);
		newTree.ParcoursMyTreeForAff(newTree.rootNode, 0);
		//newTree.AffTab2D(newTree.CutMathExprInTwo(test));
	}
}

class MyNode
{
	MyNode rightChildNode;
	MyNode leftChildNode;
	MyNode parentNode;
	String data;
}

Bonne chance

Je m'explique.

Telle que je vois les choses un arbre binaire équilibré total de profondeur
n a son niveau n-1 complètement rempli.

Dans son cas précis il veut un maximum de fils droit par niveau
je ne vois pas comment il peut atteindre ce résultat sans chercher
à équilibrer son arbre....

Bon si bien sur il n'a pas suffisamment d élément pour remplir le
dernier niveau il aura donc un arbre d'éequilibre partiel

Ma source : [url]http://fr.wikipedia.org/wiki/Arbre_équilibré[/url]

Voila, si jamais je me suis trompé n'hésites pas:)

Alors il n'est pas équilibré.

Je ne vois pas d'où tu sors ça.

:lol:
Un équilibre partiel n'est pas un équilibre ;)

Wikipedia c'est vraiment très bien, mais parfois on y trouve des choses bizarres.
Selon moi un arbre est équilibré si toutes ses feuilles sont à un même niveau de profondeur. Si ce n'est pas la cas, il n'est pas équilibré. Le partiellement équilibré n'existant pas à ma connaissance :)
Et tu peux voir ça aussi à Wikipedia (anglais)
http://en.wikipedia.org/wiki/B-tree
J'en cite un bout

Comme tu vois le niveau de profondeur des feuilles est requis, sinon tu n'as pas un arbre équilibré.

Ben oui, un arbre binaire tout simplement

Non. Enfin ça dépend de que tu entends par similaire :)

Tout ça est impeccable. Et c'est un arbre binaire

Non:
(1 + (2 + (3 + (4 + (5 + (6 + (7 + (8 + 9))))))))
Comment c'est équilibré (ou complet si c'est ce que tu as voulu dire) au niveau n-1 ?

Pas clair, je ne te le fais pas dire. J'ai moi même compris qu'il voulait constituer un arbre binaire, mais je n'ai pas bien suivi son histoire de racine. S'il veut bien poser sa question dans un français intelligible....

Quoi qu'il en soit je rends hommage à tes consistantes contributions à ce forum. J'espère que nous aurons souvent le plaisir de discuter ensemble :)

Je comprends.
Mais il me semble que ton point de départ aurait du être " fonction récursive" et "trouver". C'est plus dans l'exploitation de l'arbre que dans sa constitution qu'il a problème.

Oui qu'il donne son énoncé et surtout qu'il s'exprime dans une français intelligible (là ca va être dur je le crains)