Structure d' Arbre

Bonjour,

Voila j'ai besoin d'utiliser des arbres pour stocker des objets. J'ai vu qu'en .net les structures d'arbre n'existe pas, à moins que j'ai mal vu...

J'aimerai savoir si des bibliothèques existes déjà (open source) ou si je dois me créer mes structures ?

Cordialement ^^

Salut,

Il n'y a pas de structures d'arbres en dotnet, je prendrai également le pari pour tous les langages de poo.

Il te suffit, de créer une classe avec un propriété pointant sur le parent et une liste d'enfants.

Au vu de tes autres sujets, tu essaies peut être d'appliquer les concepts liés au C à du dotnet (liste chainée, arbres de recherche). C'est pas forcément une bonne idée, recentre-toi sur ton besoin pas sur les concepts que tu connais en C.

PS: comme en C le mot-clé structure existe en C# mais celui-ci à une utilité bien spécifique (dans la majorité des cas on crée une classe).

Merci pour ta réponse.

Effectivement, j'ai pensé comme tu l'as dis a faire simple avec une propriété pointant sur un parent et une Liste d'enfant ( ce que j'ai actuellement).

Je me posais la question sur une librairie existant au cas où je doive faire des manipulations d'arbre... ce qui m'éviterai de recoder certaines fonctions, et surtout du fait que je risque d'avoir plusieurs ensemble de données de classe différentes à mettre sous forme d'arbre.

Après tu as raison, je me base pas mal sur ce que je faisais en C et la raison c'est que j'ai plutôt fais de l'algorithmie appliquée avec du langage C. Et je bosse actuellement en C#, mais sur une partie purement algo :), ce qui fait que pour la résolution de mes problèmes et de part mon cursus, je me retrouve souvent à devoir utilisé des structures qui pour moi sont basique et évidente...

Sinon donc personne ne connait une librairie ?

bonjour

est-ce qu'une librairie comme OpenSceneGraph n'est pas dédié à la gestion d'un arbre par exemple ? (je ne sais pas si elle existe en C# par contre).

Vu que c'est une librairie C++, je n'ai pas vraiment regarder.

Une classe qui stocke des info généalogiques sous forme d'arbre pourrait se présenter ainsi :
Code:

1 2 3 4 5 6 7 8 9 10 11 internal Class MyTreeNode : List<object> { internal MyTreeNode Parent ; internal string Nom ; internal string Prenom ; internal int Age ; internal new MyTreeNode this[int index] { get { return (MyTreeNode)base[index] ; } } internal string NodeToString() { return Nom+" "+Prenom+" ("+Age.ToString()+")" ;} }
Et pour afficher tous les fils d'une personne :

Code:

for (int i=0;i<Count;i++) MessageBox.Show(MyTreeNode[i].NodeToString()) ;

bonjour angel46

Peut etre que cet exemple d'implementation d'une interface generique pour un tree (inspiree d'une pattern composite) pourrait repondre au souci....
En gros elle repond aux 4 soucis du tree:
-avoir une seule interface pour les "node leaf" et les autres "nodes" intermediares(les "boss") y compris la racine(root)....
-parcourir les childs nodes
-pour un child node donne remonter la hierarchie jusqu'à la racine....
-self promotion (convertir un NodeLeaf en noeud hierachique superieur)
-un arraylist (IEnumerable est d'un grand secours)....

l'exemple comporte en plus l'affichage sur un treeview de la hierarchie:
code .cs du class INode

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
 
namespace WinComposite
{
    public interface INode
    {
        float getSalary();   //get current salary
        string getName();    //get name
        bool isLeaf();       //true if leaf(une feuille-plus bas niveau)
        void add(string nm, float salary);   //add childnode
        void add(INode  emp);      //add childnode
        IEnumerator getChildNodes();         //get childnodes
        INode getChild();         //get child
        float getSalaries();                 //get sum of salaries(montant des salaires des enfants)
        INode getParentNode();
    }
 
    // class concrete NodeLeaf(implemente les "leafs" nodes ou "feuilles")
    public class NodeLeaf : INode
    {
        protected float salary;
        protected string name;
        protected INode  parent;
        protected ArrayList childnodes;
        //------
        public NodeLeaf(string nm, float salry)
        {
            childnodes = new ArrayList();
            name = nm;
            salary = salry;
            parent = null;
        }
        // Ref to Parent
        public NodeLeaf(INode  parnt,
                                string nm, float salry)
        {
            childnodes = new ArrayList();
            name = nm;
            salary = salry;
            parent = parnt;
        }
        //------
        public float getSalary()
        {
            return salary;
        }
        //------
        public string getName()
        {
            return name;
        }
        //------
        public bool isLeaf()
        {
            return childnodes.Count == 0;
        }
        //------
        public virtual INode getChild()
        {
            return null;
        }
 
 
        #region INode Membres
 
 
        public virtual void add(string nm, float salary)
        {
            throw new Exception(
            "No childnodes in base NodeLeaf class");
        }
 
        public virtual void add(INode  nd)
        {
            throw new Exception(
            "No childnodes in base NodeLeaf class");
        }
 
        public IEnumerator getChildNodes()
        {
            return childnodes.GetEnumerator();
        }
 
        public float getSalaries()
        {
            return salary;
        }
 
        #endregion
 
        #region INode Membres Membres
 
 
        public INode getParentNode()
        {
            return parent;
        }
 
        #endregion
 
 
 
    }
 
 
    // class concrete Node herite de NodeLeaf 
    // implemente les nodes "intermediaires" y compris le node "racine" et 
    public class Node : NodeLeaf 
    {
        public Node(string name, float salary)
            : base(name, salary)
        {
        }
        //permet de parcourir la hierarchie de haut en bas
        //sinon ArrayList ne permet le parcours qu'en avant)
        //Ref to Parent
        public Node(INode parnt,
                                string nm, float salry)
            : base(parnt, nm, salry)
        {
        }
 
        //Ctor de Self-Promotion: convertit un node leaf en node
        //node  class peut creer a node à partir d'un nodeleaf
        public Node(INode nd) :
            base(nd.getName(), nd.getSalary())
        {
        }
        public override void add(string nm, float salary)
        {
            INode  nd = new Node (nm, salary);
           childnodes.Add(nd);
        }
        //------
        public override void add(INode nd)
        {
            childnodes.Add(nd);
        }
        //------
 
        //------
        public new float getSalaries()
        {
            float  sum;
            INode  descendant;
            //get the salaries of the node and childnodes
            sum = getSalary();
            IEnumerator enumDescendant = childnodes.GetEnumerator();
            while (enumDescendant.MoveNext())
            {
                descendant = (INode)enumDescendant.Current;
                sum += descendant.getSalaries();
            }
            return sum;
        }
    }
}

code du form utilisateur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
 
namespace WinComposite
{
    public partial class frmNodes : Form
    {
        public frmNodes()
        {
            InitializeComponent();
        }
        private Random rndSalary = new Random();
        Node president, marketVP, salesMgr, advMgr, prodVP, prodMgr, shipMgr;
        private void btnBuildTree_Click(object sender, EventArgs e)
        {
            buildEmployeeList();
            buildTree();
        }
 
        //build un tree de test avec INode
        private void buildEmployeeList() 
        {
 
            president  = new Node (null,"CEO", 200000);
            marketVP = new Node( president,"Marketing VP", 100000);
            president.add(marketVP);
            salesMgr = new Node(marketVP, "Sales Mgr", 50000);
            advMgr = new Node(marketVP, "Advt Mgr", 50000);
            marketVP.add(salesMgr);
            marketVP.add(advMgr);
            //add salesmen reporting to sales manager
            for (int i = 1; i<=5; i++)
            {
                salesMgr.add("Sales" + i.ToString(),
                rndSalary.Next(30000));
            }
 
            prodVP = new Node(president, "Production VP", 100000);
            president.add(prodVP);
            advMgr.add("Secy", 20000);
            prodMgr = new Node (prodVP,"Prod Mgr", 40000);
            shipMgr = new Node (prodVP,"Ship Mgr", 35000);
            prodVP.add(prodMgr);
            prodVP.add(shipMgr);
 
            for (int i = 1; i<=3; i++)
            {
                shipMgr.add("Ship" + i.ToString(), rndSalary.Next(25000));
            }
            for (int i = 1; i<=4; i++)
            {
                prodMgr.add("Manuf" + i.ToString(), rndSalary.Next(20000));
            }
        }
        //class custom TeeNode pour display
        public class MyTreeNode : TreeNode
        {
            private INode nd;
            public MyTreeNode(INode ond) :
                base(ond.getName())
            {
                nd = ond;
 
            }
            //-----
            public INode getEmployee()
            {
                return nd;
            }
        }
        //construit le treenode pour treeview
        private void buildTree()
        {
 
            MyTreeNode rootNode = null;
            MyTreeNode nod;
            nod = new MyTreeNode(president);
            rootNode = nod;
            EmpTree.Nodes.Add(nod);
            addNodes(nod, president);
        }
        private void addNodes(MyTreeNode nod, INode  racine)
        {
            MyTreeNode ndtree;
            INode nd;
            IEnumerator enumChilds = racine.getChildNodes();
            while (enumChilds.MoveNext())
            {
                nd = (INode )enumChilds.Current;
                ndtree = new MyTreeNode(nd);
                nod.Nodes.Add(ndtree);
                //recursively
                addNodes(ndtree, nd);
            }
 
        }
        //handler treeview pour les "salaries"
        private void EmpTree_AfterSelect(object sender, TreeViewEventArgs e)
        {
            MyTreeNode node;
            node = (MyTreeNode)EmpTree.SelectedNode;
            getNodeSum(node);
        }
        private void getNodeSum(MyTreeNode node)
        {
            INode  nd;
            float sum;
            nd = node.getEmployee();
            sum = nd.getSalaries();
            lbSalary.Text = sum.ToString();
        }
        //un button pour voir hierarchie
        private void btShowNode_Click(object sender, EventArgs e)
        {
            MyTreeNode node;
            node = (MyTreeNode)EmpTree.SelectedNode;
            INode  nd = node.getEmployee();
            string hierarchies = "";
            while (nd != null)
            {
                hierarchies += nd.getName() + "\n";
                nd = nd.getParentNode();
            }
            MessageBox.Show(null, hierarchies, "Reporting chain");
        }
    }
}

en esperant que ca repond au souci........

De mon coté je suis parti sur http://dvanderboom.wordpress.com/200...ary-tree-in-c/ et j'en suis content.

Merci a tous pour vos divers réponse, je vais étudier plus précisément tous sa, et je pense me débrouillé avec ^^