Discussion :

[Djakisback]

Salut,
je cherche à faire un affichage de catégories et sous-catégories sous cette forme :

Cat1
-1.1
--1.1.1
--1.1.2
-1.2
--1.2.1
Cat2
-2.1
-2.2
--2.2.1
--2.2.2
-2.3

Mon problème se situe au niveau du décalage à ajouter avant les nomns de catégories. En l'occurence le nombre de "-" dans l'exemple.

Voici comment je stocke mes informations de catégories :
id | id_parent | name

Et enfin voici ce que j'ai pondu pour l'instant mais je bloque, il me manque quelque chose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
decalage = "";
foreach(categories as cat)	{
	// Si la catégorie n'est pas une racine
	if(!cat->estRacine())	{
		// Si on a changé de parent
		if(idParent != cat->getIdParent())	{
			decalage .= "-";
			idParent = cat->getIdParent();
		}
	}
	// Si la catégorie est une racine
	else	{
		decalage = ""; // Je remet le décalage à 0
		idParent = 0; // Ici je remets l'idParent à 0 car une catégorie racine a 0 en idParent
	}
	affiche decalage.cat->getName();

En fait ceci me décale relativement comme il faut. Il y a en fait un problème car le décalage se remet à 0 uniquement si la catégorie est une racine.
Ce qui me donne à l'affichage un truc du style :

Cat1
-1.1
--1.1.1
--1.1.2
---1.2
----1.2.1
Cat2
-2.1
-2.2
--2.2.1
--2.2.2
---2.3

Voilà si quelqu'un a une idée pour résoudre ce problème ou un tout autre algo, ca m'intéresse bien ^^
Merci d'avance et a+

[millie]

T'utilises la notion de parents, de racine comme pour un arbre.

Le nombre de -, c'est simplement la profondeur de l'arbre de la racine au sommet où tu te trouves.

[Djakisback]

Si je veux pouvoir calculer la profondeur je suis obligé de construire l'arbre avant par contre ?

[Trap D]

Ça ne peut pas se traiter par une procédure récursive ?

[Jean-Marc.Bourguet]

Il ne faut ajouter un niveau que si le parent du nouveau noeud est le noeud précédent. Si ce n'est pas le cas, il faut enlever des niveaux... quelque chose du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  if(!cat->estRacine())	{
		// Si on a changé de parent
		if(pred->getIdParent == cat->getIdParent())	{
                   // rien
                } else if (cat->getIdParent() == pred) {
			decalage .= "-";
			idParent = cat->getIdParent();
		} else {
                   do {
                      decalage.pop_back(); // ou ce qu'il faut pour supprimer
                      pred = pred->getIdParen();
                   } while(pred->getIdParent != cat->getIdParent());
                }
                pred = cat;
	}
	// Si la catégorie est une racine
	else	{
		decalage = ""; // Je remet le décalage à 0
		idParent = 0; // Ici je remets l'idParent à 0 car une catégorie racine a 0 en idParent
	}

[borisd]

Je sais que ma proposition n'est pas très recherchée et que çe n'est pas vraiment propre (optimisé), mais je la trouve tellement simple...
Est-ce qu'il ne suffirait pas de recompter à chaque fois le nombre de points de l'id du parent (il est bien représenté par une chaîne de caractères) ?
Ca se fait en O(taille_idParent), ce qui est pareil au pire cas que la proposition de Jean-Marc Bourguet. Certes au total on fait plus de trucs inutiles, mais pas un si grand nombre que ça s'il n'y a pas 2000 sous-catégories...

[Djakisback]

Salut et merci pour vos réponses ^^
Je me suis inspiré de la méthode de Jean-Marc.Bourguet et ca fonctionne nickel

borisd> Pour ta technique je crois que de toute façon t'es obligé de stocker quand même l'id du parent.

Pour la récursivité quand je peux m'en passer j'hésite pas

Bye