|
|
|
|
| | FigB.png " fileSize " > (27 KB) " javascript för href= " för <-/span> <-/div> |
When som " " för > | | <-/div> | | | We, genom att simulera radering av 28.
A) 29, tar 28's place.
B) som vi frågar knutpunkt på 29 för att finna ett nytt utrymme för 20.
Then vi simulerar radering av 10.
I) 14 tar 10s place.
II) vi frågar 14 för att finna nytt utrymme för logik för 3.
The är samma i båda exempel, only behandla olika sidor av en given knutpunkt (beroende av vilken sida knutpunkten är på det, tas bort).
> för
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:
" codeBody "
" SubTree för >class för class= " för =newValue) {
om (leftTree! = ogiltigt) {
leftTree.insertValue (newValue);
} annars {
leftTree = ny SubTree (newValue, denna);
}
} annars {
om (rightTree! = ogiltigt) {
rightTree.insertValue (newValue);
} annars {
rightTree = ny SubTree (newValue, denna);
}
}
}
allmänhet stränger toString () {
Stränga returString = "";
om (leftTree! = ogiltigt) {
returString = leftTree.toString () + ””;
}
returString = returString + värderar;
om (rightTree! = ogiltigt) {
returString = returString + ””+ rightTree.toString ();
}
showObject ();
återgång returString;
}
offentlig boolean lookForValue (int-søkeVerdien) {
om (søkeVerdi== värderar) {
återgångt true;
}
om (värdera > søkeVerdien) {
om (leftTree! = ogiltigt) {
återgång leftTree.lookForValue (søkeVerdi);
} annars {
återgångt falskt;
}
} annars {
om (rightTree! = ogiltigt) {
återgång rightTree.lookForValue (søkeVerdi);
} annars {
återgångt falskt;
}
}
}
offentlig boolean deleteValue (int värderar) {
om (this.value-== värderar) {
//If har vi funnit knutpunkt med rätt värderar, oss måste att finna, om den har några barnknutpunkter
om ((ogiltig rightTree==) && (ogiltig leftTree==)) {
/** Denna knutpunkt har inget barn, det kan anknytas av tree.*en/
om (värdera <= this.parent.getValue ()) {//We är på vänster sida, och vi ska relink där på föräldern
this.parent.relink (0, ogiltigt);
} annars {//We är på rätsidan, och vi relink där på föräldern
this.parent.relink (1, ogiltigt);
}
//At avsluta som vi relink denna, anmärker backreference för att uppfostra:
this.parent = ogiltigt;
återgångt true;
} annars om (((ogiltig rightTree==) && (leftTree! = ogiltigt)) || ((rightTree! = ogiltig) && (ogiltig leftTree==))) {
/** Knutpunkten har endast en barnknutpunkt. Vi anknyter över denna knutpunkt till barnet *
om (värdera <= this.parent.getValue ()) {//We är på vänster sida, och vi anknyter över denna anmärker där till denna anmärker rightTree
om ((rightTreen! = ogiltig) && (ogiltig leftTree==)) this.parent.relink (0, this.rightTree);
om ((ogiltig rightTree==) && (leftTree! = ogiltigt)) this.parent.relink (0, this.leftTree);
this.rightTree = ogiltigt;
} annars {//Or vi är annars på rätsidan, och vi anknyter över denna anmärker där till denna anmärker leftTree
om ((rightTreen! = ogiltig) && (ogiltig leftTree==)) this.parent.relink (1, this.rightTree);
om ((ogiltig rightTree==) && (leftTree! = ogiltigt)) this.parent.relink (1, this.leftTree);
this.leftTree = ogiltigt;
}
//At avsluta som vi relink denna, anmärker hänvisar till till föräldern:
this.parent = ogiltigt;
återgångt true;
} annars {
/** Nodenen har två barnknutpunkter, dessa måste rört korrekt och förlagt korrekt under förälderknutpunkten *
om (värdera <= this.parent.getValue ()) {//We är på vänster sida, oss anknyter höger barnknutpunkt på vänster sida på föräldern
//We frågar därefter den högra barnknutpunkten för att finna nytt utrymme för den lämnade childnoden
this.parent.relink (0, this.rightTree);
this.rightTree.giveNewPlace (this.leftTree);
this.rightTree = ogiltigt;
this.leftTree = ogiltigt;
this.parent = ogiltigt;
} annars {//Or vi är annars på rätsidan, och vi anknyter höger barnknutpunkt på rätsidan på föräldern
this.parent.relink (1, this.rightTree);
this.rightTree.giveNewPlace (this.leftTree);
this.rightTree = ogiltigt;
this.leftTree = ogiltigt;
this.parent = ogiltigt;
}
this.parent = ogiltigt;
återgångt true;
}
} annars {
//If vi har inte foumd knutpunkten med det korrekt att värdera, vi ska söker efter det korrekta barnet noterar och ser där:
om (this.value < värderar) {
om (rightTree! = ogiltig) rightTree.deleteValue (värdera);
} annars {
om (leftTree! = ogiltig) leftTree.deleteValue (värdera);
}
}
gå falskt tillbaka;
}
offentlig int-getValue () {
återgång this.value;
}
offentligt utan laga kraft relink (int i, SubTree t) {
om (I > 0) {
this.rightTree = t;
} annars {
this.leftTree = t;
}
t.setNewParent (denna);
}
offentlig SubTreegetChildNode (int i) {
om (I > 0) {
återgång this.rightTree;
} annars {
återgång this.leftTree;
}
}
offentlig utan laga kraft giveNewPlace (SubTree t) {
//Takes SubTree t och försök för att ge den som ett nytt förlägger i treen
//Check, om denna knutpunkt har utrymme för en lämnad barnknutpunkt, om inte:
//Check, om denna knutpunkt har utrymme för en höger barnknutpunkt och beställer de två korrekta childnodesna, om inte:
//Ask den nästa lämnade childNoden som ger nytt, förlägger med dess giveNewPlace ().
om (ogiltig this.leftTree-==) {
this.leftTree = t;
t.setNewParent (denna);
} annars, om (ogiltig this.rightTree-==) {
om (getValue () < t.getValue ()) {
this.rightTree = t;
t.setNewParent (denna);
} annars {
this.rightTree = this.leftTree;
this.leftTree = t;
t.setNewParent (denna);
}
} annars {
this.leftTree.giveNewPlace (t);
}
}
offentligt utan laga kraft setNewParent (SubTree t) {
this.parent = t;
}
offentlig utan laga kraft showObject () {
System.out.println (”,----------------------------------------”);
om (förälder! = ogiltig) System.out.println (”förälder: ” + parent.getValue ());
System.out.println (”*Value: ” + this.value);
om (rightTree! = ogiltig) System.out.println (”högert barn: ” + rightTree.getValue ());
om (leftTree! = ogiltig) System.out.println (”lämnade barnet: ” + leftTree.getValue ());
System.out.println (”,----------------------------------------”);
}
}
klassificera BinarySeekingTree {
privat SubTreeröta;
allmänhet stränger toString () {
om (röta! = ogiltigt) {
återgång rot.toString ();
} annars {
återgångt ogiltigt;
}
}
offentlig utan laga kraft insertValue (int värderar) {
om (röta! = ogiltigt) {
rot.insertValue (värdera);
} annars {
röta = ny SubTree (värdera, ogiltigt);
}
}
offentlig boolean deleteValue (int värderar) {
//If där är ingen rotar i treen, då det finns inget värderar för att ta bort
om (ogiltig röta==) {
återgångt falskt;
} annars {
om (rot.deleteValue (värdera)), {
gå riktigt tillbaka;
} annars {
återgångt falskt;
}
}
}
offentlig boolean lookForValue (int-søkeVerdien) {
om (ogiltig röta==) {
återgångt falskt;
}
återgång rot.lookForValue (søkeVerdi);
}
}
klassificera sökanden {
utan laga kraft huvudsakligt för offentlig statisk elektricitet (stränga [] args) {
BinarySeekingTree tree = nya 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 (”treen i en sorterad skärm: ” + tree.toString ()); //Sorting kuggningar, når att ha tagit bort en anmärka
System.out.println (”är 3 i treen: ” + tree.lookForValue (3));
System.out.println (”är 4 i treen: ” + tree.lookForValue (4));
System.out.println (”är 1 i treen: ” + tree.lookForValue (1));
System.out.println (”är 10 i treen: ” + tree.lookForValue (10));
System.out.println (”är 12 i treen: ” + tree.lookForValue (12));
System.out.println (”är 13 i treen: ” + tree.lookForValue (13));
System.out.println (”är 14 i treen: ” + tree.lookForValue (14));
System.out.println (”är 16 i treen: ” + tree.lookForValue (16));
System.out.println (”är 20 i treen: ” + tree.lookForValue (20));
System.out.println (”är 21 i treen: ” + tree.lookForValue (21));
System.out.println (”är 28 i treen: ” + tree.lookForValue (28));
System.out.println (”är 29 i treen: ” + tree.lookForValue (29));
System.out.println (”är 30 i treen: ” + tree.lookForValue (30));
System.out.println (”är 39 i treen: ” + tree.lookForValue (39));
System.out.println (”oss nu försök att ta bort värdera 10 från treen, bara inte 28. ”);
tree.deleteValue (10);
//tree.deleteValue (28);
System.out.println ("");
System.out.println (”treen i en sorterad skärm: ” + tree.toString ()); //Sorting kuggningar, når att ha tagit bort en anmärka
System.out.println (”är 3 i treen: ” + tree.lookForValue (3));
System.out.println (”är 4 i treen: ” + tree.lookForValue (4));
System.out.println (”är 1 i treen: ” + tree.lookForValue (1));
System.out.println (”är 10 i treen: ” + tree.lookForValue (10));
System.out.println (”är 12 i treen: ” + tree.lookForValue (12));
System.out.println (”är 13 i treen: ” + tree.lookForValue (13));
System.out.println (”är 14 i treen: ” + tree.lookForValue (14));
System.out.println (”är 16 i treen: ” + tree.lookForValue (16));
System.out.println (”är 20 i treen: ” + tree.lookForValue (20));
System.out.println (”är 21 i treen: ” + tree.lookForValue (21));
System.out.println (”är 28 i treen: ” + tree.lookForValue (28));
System.out.println (”är 29 i treen: ” + tree.lookForValue (29));
System.out.println (”är 30 i treen: ” + tree.lookForValue (30));
System.out.println (”är 39 i treen: ” + tree.lookForValue (39));
}
}
" klar "
|
|
Svar : Logiska fel Java för binär Tree
|
Ditt kodifiera skulle arbete riktigt, om den skulle treen återstår allsidig efter radering. Det huvudsakligt orsakar av ditt problem är förklarat nedanfört:
Är här den de lämnade subtreen, efter du har tagit bort knutpunkten med har värderat 10.
14
/\,
3 12
/\ \,
1 4 13
Om vi önskar att finna knutpunkten med, värdera 12, enligt ditt kodifierar 12na jämförs med 14. Om 12na <� 14="">som löser problemet dig bör uppehället som treen balanserade.
|
|
|
|
|
| |
|
|
