class= " lineNumbers " de
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 :
163 :
164 :
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 :
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 :
261 :
262 :
263 :
264 :
|
class= de
sous-arbre " de " codeSnippet781788 d'id= " de class de class= {
rightTree = nulle privés de sous-arbre ;
leftTree = nulle privés de sous-arbre ;
parent = nulle privés de sous-arbre ;
valeur privée d'international = 0 ;
sous-arbre public (valeur d'international) {
this.value = valeur ;
}
sous-arbre public (valeur d'international, parent de sous-arbre) {
this.value = valeur ;
this.parent = parent ;
}
insertValue vide de public (newValue d'international) {
si (newValue de >= de valeur) {
si (leftTree ! = nulle) {
leftTree.insertValue (newValue) ;
} autrement {
leftTree = nouveau sous-arbre (newValue, ceci) ;
}
} autrement {
si (rightTree ! = nulle) {
rightTree.insertValue (newValue) ;
} autrement {
rightTree = nouveau sous-arbre (newValue, ceci) ;
}
}
}
corde publique toString () {
Corde returString = "" ;
si (leftTree ! = nulle) {
returString = leftTree.toString () + « « ;
}
returString = returString + valeur ;
si (rightTree ! = nulle) {
returString = returString + « « + rightTree.toString () ;
}
showObject () ;
returString de retour ;
}
lookForValue booléen public (søkeVerdi d'international) {
si (valeur de == de søkeVerdi) {
de retour rectifier ;
}
si (valeur > søkeVerdi) {
si (leftTree ! = nulle) {
leftTree.lookForValue de retour (søkeVerdi) ;
} autrement {
faux de retour ;
}
} autrement {
si (rightTree ! = nulle) {
rightTree.lookForValue de retour (søkeVerdi) ;
} autrement {
faux de retour ;
}
}
}
deleteValue booléen public (valeur d'international) {
si (valeur de == de this.value) {
//If nous avons trouvé le noeud avec la bonne valeur, nous devons trouver si elle a n'importe quels noeuds d'enfant
si (&& (de nulle de == de rightTree) (nulle de == de leftTree)) {
/** Ce noeud n'a aucun enfant, il peut être lié outre du tree.*/
si (<= this.parent.getValue de valeur ()) {//We sont d'aile gauche, et nous reconnecterons là au parent
this.parent.relink (0, nulle) ;
} autrement {//We sont du côté droit, et nous reconnectons là au parent
this.parent.relink (1, nulle) ;
}
//At l'extrémité nous reconnectons ce backreference d'objets pour parent :
this.parent = nulle ;
de retour rectifier ;
} autrement si ((&& (de nulle de == de rightTree) (leftTree ! = nulle)) || ((rightTree ! = && de nulle) (nulle de == de leftTree))) {
/** Le noeud a seulement un noeud d'enfant. Nous lions au-dessus de ce noeud à l'enfant *
si (<= this.parent.getValue de valeur ()) {//We sont d'aile gauche, et nous lions là au-dessus de cet objet à ce rightTree d'objets
si ((rightTree ! = && de nulle) (nulle de == de leftTree)) this.parent.relink (0, this.rightTree) ;
si (&& (de nulle de == de rightTree) (leftTree ! = nulle)) this.parent.relink (0, this.leftTree) ;
this.rightTree = nulle ;
} autrement {//Or autrement nous sommes du côté droit, et nous lions là au-dessus de cet objet à ce leftTree d'objets
si ((rightTree ! = && de nulle) (nulle de == de leftTree)) this.parent.relink (1, this.rightTree) ;
si (&& (de nulle de == de rightTree) (leftTree ! = nulle)) this.parent.relink (1, this.leftTree) ;
this.leftTree = nulle ;
}
//At l'extrémité nous reconnectons cette référence d'objets au parent :
this.parent = nulle ;
de retour rectifier ;
} autrement {
/** Le noden a deux noeuds d'enfant, ceux-ci doivent déplacé correctement et placé correctement sous le noeud de parent *
si (<= this.parent.getValue de valeur ()) {//We sont de l'aile gauche, nous lient le bon noeud d'enfant de l'aile gauche au parent
//We demandent alors au bon noeud d'enfant de trouver le nouvel espace pour le childnode gauche
this.parent.relink (0, this.rightTree) ;
this.rightTree.giveNewPlace (this.leftTree) ;
this.rightTree = nulle ;
this.leftTree = nulle ;
this.parent = nulle ;
} autrement {//Or autrement nous sommes du côté droit, et nous lions le bon noeud d'enfant du côté droit au parent
this.parent.relink (1, this.rightTree) ;
this.rightTree.giveNewPlace (this.leftTree) ;
this.rightTree = nulle ;
this.leftTree = nulle ;
this.parent = nulle ;
}
this.parent = nulle ;
de retour rectifier ;
}
} autrement {
//If nous n'avons pas le foumd le noeud avec la valeur correcte, nous rechercherons la note correcte d'enfant et regarderons là :
si (this.value < valeur) {
si (rightTree ! = nulle) rightTree.deleteValue (valeur) ;
} autrement {
si (leftTree ! = nulle) leftTree.deleteValue (valeur) ;
}
}
faux de retour ;
}
getValue public d'international () {
this.value de retour ;
}
le vide de public reconnectent (international i, sous-arbre t) {
si (I > 0) {
this.rightTree = t ;
} autrement {
this.leftTree = t ;
}
t.setNewParent (ceci) ;
}
getChildNode public de sous-arbre (international i) {
si (I > 0) {
this.rightTree de retour ;
} autrement {
this.leftTree de retour ;
}
}
giveNewPlace vide de public (sous-arbre t) {
Sous-arbre t de //Takes et essais pour lui donner un nouvel endroit dans l'arbre
//Check si ce noeud a l'espace pour un noeud d'enfant gauche, sinon :
//Check si ce noeud a l'espace pour un bon noeud d'enfant et commande les deux childnodes corrects, sinon :
//Ask le prochain childNode gauche pour donner le nouvel endroit avec son giveNewPlace ().
si (nulle de == de this.leftTree) {
this.leftTree = t ;
t.setNewParent (ceci) ;
} autrement si (nulle de == de this.rightTree) {
si (getValue () < t.getValue ()) {
this.rightTree = t ;
t.setNewParent (ceci) ;
} autrement {
this.rightTree = this.leftTree ;
this.leftTree = t ;
t.setNewParent (ceci) ;
}
} autrement {
this.leftTree.giveNewPlace (t) ;
}
}
setNewParent vide de public (sous-arbre t) {
this.parent = t ;
}
showObject vide de public () {
System.out.println (« ----------------------------------------") ;
si (parent ! = nulle) System.out.println (« parent : » + parent.getValue ());
System.out.println (« *Value : » + this.value) ;
si (rightTree ! = nulle) System.out.println (« enfant droit : » + rightTree.getValue ());
si (leftTree ! = nulle) System.out.println (« enfant laissé : » + leftTree.getValue ());
System.out.println (« ----------------------------------------") ;
}
}
classe BinarySeekingTree {
putréfaction privée de sous-arbre ;
corde publique toString () {
si (putréfaction ! = nulle) {
rot.toString de retour () ;
} autrement {
nulle de retour ;
}
}
insertValue vide de public (valeur d'international) {
si (putréfaction ! = nulle) {
rot.insertValue (valeur) ;
} autrement {
putréfaction = nouveau sous-arbre (valeur, nulle) ;
}
}
deleteValue booléen public (valeur d'international) {
//If là n'est aucune racine dans l'arbre, puis il n'y a aucune valeur à supprimer
si (nulle de == de putréfaction) {
faux de retour ;
} autrement {
si (rot.deleteValue (valeur)) {
de retour rectifier ;
} autrement {
faux de retour ;
}
}
}
lookForValue booléen public (søkeVerdi d'international) {
si (nulle de == de putréfaction) {
faux de retour ;
}
rot.lookForValue de retour (søkeVerdi) ;
}
}
recherche de classe {
vide public de charge statique principal (args de corde []) {
Arbre de BinarySeekingTree = nouveau BinarySeekingTree () ;
tree.insertValue (15) ;
tree.insertValue (10) ;
tree.insertValue (28) ;
tree.insertValue (3) ;
tree.insertValue (14) ;
tree.insertValue (20) ;
tree.insertValue (29) ;
tree.insertValue (1) ;
tree.insertValue (4) ;
tree.insertValue (12) ;
tree.insertValue (13) ;
tree.insertValue (16) ;
tree.insertValue (21) ;
tree.insertValue (30) ;
tree.insertValue (39) ;
System.out.println (« l'arbre dans un affichage assorti : » + tree.toString ()); //Sorting échoue après la suppression d'un objet
System.out.println (« est 3 dans l'arbre : » + tree.lookForValue (3)) ;
System.out.println (« est 4 dans l'arbre : » + tree.lookForValue (4)) ;
System.out.println (« est 1 dans l'arbre : » + tree.lookForValue (1)) ;
System.out.println (« est 10 dans l'arbre : » + tree.lookForValue (10)) ;
System.out.println (« est 12 dans l'arbre : » + tree.lookForValue (12));
System.out.println (« est 13 dans l'arbre : » + tree.lookForValue (13));
System.out.println (« est 14 dans l'arbre : » + tree.lookForValue (14));
System.out.println (« est 16 dans l'arbre : » + tree.lookForValue (16));
System.out.println (« est 20 dans l'arbre : » + tree.lookForValue (20));
System.out.println (« est 21 dans l'arbre : » + tree.lookForValue (21));
System.out.println (« est 28 dans l'arbre : » + tree.lookForValue (28));
System.out.println (« est 29 dans l'arbre : » + tree.lookForValue (29));
System.out.println (« est 30 dans l'arbre : » + tree.lookForValue (30));
System.out.println (« est 39 dans l'arbre : » + tree.lookForValue (39));
System.out.println (« nous essayons maintenant de supprimer la valeur 10 de l'arbre, mais non 28.") ;
tree.deleteValue (10) ;
//tree.deleteValue (28) ;
System.out.println ("") ;
System.out.println (« l'arbre dans un affichage assorti : » + tree.toString ()); //Sorting échoue après la suppression d'un objet
System.out.println (« est 3 dans l'arbre : » + tree.lookForValue (3)) ;
System.out.println (« est 4 dans l'arbre : » + tree.lookForValue (4)) ;
System.out.println (« est 1 dans l'arbre : » + tree.lookForValue (1)) ;
System.out.println (« est 10 dans l'arbre : » + tree.lookForValue (10)) ;
System.out.println (« est 12 dans l'arbre : » + tree.lookForValue (12));
System.out.println (« est 13 dans l'arbre : » + tree.lookForValue (13));
System.out.println (« est 14 dans l'arbre : » + tree.lookForValue (14));
System.out.println (« est 16 dans l'arbre : » + tree.lookForValue (16));
System.out.println (« est 20 dans l'arbre : » + tree.lookForValue (20));
System.out.println (« est 21 dans l'arbre : » + tree.lookForValue (21));
System.out.println (« est 28 dans l'arbre : » + tree.lookForValue (28));
System.out.println (« est 29 dans l'arbre : » + tree.lookForValue (29));
System.out.println (« est 30 dans l'arbre : » + tree.lookForValue (30));
System.out.println (« est 39 dans l'arbre : » + tree.lookForValue (39));
}
}
|
