Discussion :

[Kobe70]

Bonjour,
Je fais du java depuis 6 mois et pour un stage en bioinformatique je dois réaliser un arbre n-aire.
Dans cet arbre je dois pouvoir construire des noeuds carrés ou des noeuds ronds.
Les noeuds ronds peuvent etre: -soit noir, soit blanc
-doivent pouvoir contenir 2 entiers
Un noeud carré est toujours le parent d'un ou plusieurs noeuds ronds
Un noeud rond est toujours le descendant d'un noeud carré
j'ai mis un exemple de structure de mon arbre en piece jointe (arbre.gif)

Merci de bien vouloir me venir en aide

[Sanguko]

Quelle est la question ?

[CyberChouan]

Renseigne-toi sur le polymorphisme en java... tu verras que ton problème d'arbre deviendra tout de suite beaucoup plus simple en concevant correctement tes classes et leurs relations.

[Kobe70]

ma question est de savoir comment faire une classe d'arbre n-aire que je puisse parcourir????
Est ce que quelqu'un saurait ou trouver une classe qui pourrait repondre a mon probleme ou peut etre que quelqu'un possede une classe de ce type?

[mythrys]

la classe DefaultMutableTreeNode pourrait faire ca

[Kobe70]

Serait-il possible d'avoir quelques informations sur l'utilisation de defaultmutabletreenode??
N'ayant jamais utililisé d'arbres je suis un peu perdu

[Sanguko]

Il n'y a pas a ma connaissance de classe toute faite pour les arbres n-aires.

Il n'y a pas non plus de code tout fait pour résoudre ton exercice.

La classe proposée se trouve dans la package javax.swing.tree, ce que tu aurais pu découvrir en utilisant google.

[yassiin]

J'ai le même problème que toi est ce que tu peut m'aider ?

D'avance merci

[kolodz]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.ArrayList;
import java.util.List;
 
public abstract class Node {
	protected List<Node> childs = new ArrayList<Node>();
 
	public List<Node> getChilds() {
		return childs;
	}
 
	public void removeChild(Node node){
		this.childs.remove(node);
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
public class NodeSquare extends Node{
 
	public NodeSquare(NodeRound child) {
		this.childs.add(child);
	}
	public void addChild(NodeRound node){
		this.childs.add(node);
	}
}

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
 
public class NodeRound extends Node{
	enum NodeColor{BLACK, WHITE};
 
	private NodeColor color=null;
        public int x,y;
	public NodeRound(NodeColor color) {
		this.color = color;
	}
	public void setColor(NodeColor color) {
		this.color = color;
	}
	public NodeColor getColor() {
		return color;
	}
 
}

Note que pour les propriétés int j'ai fait ça rapidement...

Cordialement,
Patrick Kolodziejczyk.

[Logan Mauzaize]

La forme et les couleurs ne serait-elle pas des propriétés (attributs) d'un noeud plutôt qu'une identitié (classe) ?

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
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
 
public class Node<T> extends AbstractList<Node<T>> implements RandomAccess {
   private T value;
   private Node<T> parent;
   private List<Node<T>> children = new ArrayList<Node<T>>();
 
   protected Node(T value, Node<T> parent)  {
     this.value = value;
     this.parent = parent;
   }
 
   public Node(T value) {
     this(value, null);
   }
 
   public Node() {
     this(null);
   }
 
   public T getValue() {
     return value;
   }
 
   public void setValue(T value) {
     this.value = value;
   }
 
   public Node<T> getParent() {
     return parent;
   }
 
   protected void setParent(Node<T> parent) {
     this.parent = parent;
   }
 
   public boolean isRoot() {
      return getParent() == null;
   }
 
   public Node<T> getRoot() {
     Node<T> parent = getParent();
     if (isRoot()) return this;
     return parent.getRoot();
   }
 
   protected List<Node<T>> getChildren() {
     return children;
   }
 
   public boolean isLeaf() {
      return getChildren().isEmpty();
   }
 
   @Override
   public int size() {
      return getChildren().size();
   }
 
   @Override
   public Node<T> get(int index) {
      return getChildren().get(index);
   }
 
   @Override
   public void add(int index, Node<T> child) {
      Node<T> root = child.getRoot();
      if (root != null) {
         throw new IllegalArgumentException(child + " is already attached to the tree [root: " + root + "]");
      }
      child.setParent(this);
      getChildren().add(index, child);
   }
 
   @Override
   public boolean remove(Object o) {
      if (o != null && o instanceof Node) {
         Node<T> node = (Node<T>) o;
         Iterator<Node<T>> children = getChildren().iterator();
         while (children.hasNext()) {
            Node<T> child = children.next();
            if (child == node) {
               child.setParent(null);
               children.remove();
               return true;
            }
         }
      }
      return false;
   }
 
   @Override
   protected void removeRange(int fromIndex, int toIndex) {
      List<Node<T>> children = getChildren().subList(fromIndex, toIndex);
      for (Node<T> child : children) {
         child.setParent(null);
      }
      children.clear();
   }
 
   @Override
   public Node<T> set(int index, Node<T> child) {
      Node<T> root = child.getRoot();
      if (root != null) {
         throw new IllegalArgumentException(child + " is already attached to the tree [root: " + root + "]");
      }
      Node<T> old = getChildren().set(index, child);
      child.setParent(this);
      old.setParent(null);
      return old;
   }
 
   @Override
   public int hashCode() {
      return (getValue() != null ? getValue().hashCode() : 0) + 2 * ((getChildren().hashCode()));
   }
 
   @Override
   public boolean equals(Object o) {
      if (o == null || !(o instanceof Node)) return false;
      Node<T> node = (Node<T>) o;
      return
         (getValue() == node.getValue() || (getValue() != null && getValue().equals(node.getValue()))) &&
         getChildren().equals(node.getChildren());
   }
 
   @Override
   public String toString() {
      return "node[" + getValue() + ";" + getChildren() + "]"; 
   }
 }
 
public enum Color { WHITE, BLACK; }
public enum Shape { CIRCLE, SQUARE; }
 
public class NodeProperty {
   private Color color = Color.WHITE;
   private Shape shape = Shape.CIRCLE;
 
   public Color getColor() {
 
      return this.color;
   }
   public void setColor(Color color) {
 
      this.color = color;
   }
   public Shape getShape() {
 
      return this.shape;
   }
   public void setShape(Shape shape) {
 
      this.shape = shape;
   }
}