Frage : Java-binärer Baum-logische Störungen

Ich schließe hier den Code für einen binären Baum ein. Es gibt einige Probleme mit dem Code. Der Baum ist zuerst leer, dann werden Werte eingesetzt. Der erste Wert ist an der Oberseite. Der folgende Wert ist auf der linken Seite der ersten Werte, wenn er dann der erste Wert kleiner ist. Er wird auf die rechte Seite gesetzt, wenn er dann der Anfangswert größer ist. Dieser Wert ist der erste Wertkindnullpunkt, und der erste Wert ist sein Elternteil. Wenn ein Wert einen linken und rechten Kindnullpunkt hat, verursachen jene Nullpunkte wieder neue Kindnullpunkte durch die gleiche Logik, wenn neue Werte im Baum eingesetzt werden. In diesem Beispiel I verwendet die Werte 1 3 4 10 12 13 14 15 16 20 21 28 29 30 39. Ich lösche dann Wert 10 und sehe, wenn ich den Baum richtig neu ordnen kann. Der Anfangsbaum soll wie aussehen, wie in der Abbildung A.

1), wenn ich den Nullpunkt mit Wert 10 ich lösche, der Logik folgen, die in der Abbildung B. angezeigt wird. Alles scheint, O.K. zu arbeiten, und alle Zahlen, die bleiben, werden, aber angezeigt, beim Suchen nach allen Werten, der Mechanismus scheint, zu berichten, dass einige der Zahlen fehlen. Gleich nach Auflistung sie im Auftrag. Beispiel:

" der Baum in einer sortierten Anzeige: 1 3 4 14 12 13 15 16 20 21 28 29 30 39
Is 3 im Baum: true
Is 4 im Baum: true
Is 1 im Baum: true
Is 10 im Baum: false
Is 12 im Baum: false
Is 13 im Baum: false
Is 14 im Baum: true
Is 16 im Baum: true
Is 20 im Baum: true
Is 21 im Baum: true
Is 28 im Baum: true
Is 29 im Baum: true
Is 30 im Baum: true
Is 39 im Baum: zutreffendes "

This geschieht, nur wenn es 10 (Kindnullpunkt der linken Seite), aber nicht 28 löscht (Kindnullpunkt der rechten Seite).

2) der Auftrag der Zahlen scheint, herum jongliert nach Auslassung zu erhalten. Ich bin nicht in der Lage gewesen, herauszufinden warum. Nachdem ich Nullpunkt mit Wert 10 gelöscht habe, erhalte ich diesen Auftrag: 1 3 4 14 12 13 15 16 20 21 28 29 30 39
Here können Sie sehen, dass 14 falsch gesetzt wird. Dieses geschieht nicht, wenn Nullpunkt mit Wert 28.

Figure A gelöscht wird:
FigA.png (21 KBs) (Akten-Art Details)
Figure A
das 323583


Figure B:
FigB.png (27 KBs) (Akten-Art Details)
Figure B
das 323584


When Nullpunkte der rechten Seite löschend:
We Anfang, indem er Auslassung von 28.
A) 29 simuliert, nimmt 28's place.
B), das simulieren wir bitten um um Nullpunkt bei 29, um einen neuen Raum für 20.

Then zu finden wir Auslassung von 10.
I) 14 nehmen 10 place.
II) wir 14 bitten, um neuen Raum für 3.

The Logik zu finden sind die selben in beiden Beispielen, nur, verschiedene Seiten eines gegebenen Nullpunktes behandelnd (abhängig von, welcher Seite der Nullpunkt auf dem ist, wird gelöscht). 
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:
6:
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 Unterbaum {
  privates UnterbaumrightTree = -null;
  privates UnterbaumleftTree = -null;
  privates Unterbaumelternteil = -null;
  privater int-Wert = 0;

  allgemeiner Unterbaum (int-Wert) {
    this.value = Wert;
  }

  allgemeiner Unterbaum (int-Wert, Unterbaumelternteil) {
    this.value = Wert;
    this.parent = Elternteil;
  }

  Öffentlichkeit leeres insertValue (int newValue) {
    wenn (Wert >= newValue) {
      wenn (leftTree! = Null) {
        leftTree.insertValue (newValue);
      } sonst {
        leftTree = neuer Unterbaum (newValue, dieses);
      }
    } sonst {
      wenn (rightTree! = Null) {
        rightTree.insertValue (newValue);
      } sonst {
        rightTree = neuer Unterbaum (newValue, dieses);
      }
    }
  }

  allgemeine toString Schnur () {
    returString Schnur = "";
    wenn (leftTree! = Null) {
      returString = leftTree.toString () + „„;
    }
    returString = returString + Wert;
    wenn (rightTree! = Null) {
      returString = returString + „„+ rightTree.toString ();
    }
	showObject ();
    RückholreturString;
  }

  allgemeines Boolesches lookForValue (int søkeVerdi) {
    wenn (søkeVerdi == Wert) {
      Rückhol ausrichten;
    }
    wenn (Wert > søkeVerdi) {
      wenn (leftTree! = Null) {
        RückholleftTree.lookForValue (søkeVerdi);
      } sonst {
        Rückholfalsches;
      }
    } sonst {
      wenn (rightTree! = Null) {
        RückholrightTree.lookForValue (søkeVerdi);
      } sonst {
        Rückholfalsches;
      }
    }
  }
  
  allgemeines Boolesches deleteValue (int-Wert) {
    wenn (this.value == Wert) {
	//If haben wir Nullpunkt mit rechtem Wert, wir müssen finden gefunden, wenn er irgendwelche Kindnullpunkte hat
	  wenn ((rightTree == Null) && (leftTree == Null)) {
	    /** Dieser Nullpunkt hat kein Kind, es kann weg vom tree.*/verbunden werden
		wenn (Wert <= this.parent.getValue ()) {//We sind auf linker Seite, und wir relink dort am Elternteil
			this.parent.relink (0, Null);
		} sonst {//We sind auf der rechten Seite, und wir relink dort am Elternteil
			this.parent.relink (1, Null);
		}
		//At das Ende relink wir dieses Gegenstände backreference parent:
		this.parent = Null;
		Rückhol ausrichten;
	  } sonst wenn (((rightTree == Null) && (leftTree! = Null)) || ((rightTree! = Null) && (leftTree == Null))) {
	    /** Der Nullpunkt hat nur einen Kindnullpunkt. Wir verbinden über diesem Nullpunkt mit dem Kind *
		wenn (Wert <= this.parent.getValue ()) {//We sind auf linker Seite, und wir verbinden dort über diesem Gegenstand mit diesem Gegenstände rightTree
			wenn ((rightTree! = Null) && (leftTree == Null)) this.parent.relink (0, this.rightTree);
			wenn ((rightTree == Null) && (leftTree! = Null)) this.parent.relink (0, this.leftTree);
			this.rightTree = Null;
		} sonst {//Or sonst sind wir auf der rechten Seite, und wir verbinden dort über diesem Gegenstand mit diesem Gegenstände leftTree
			wenn ((rightTree! = Null) && (leftTree == Null)) this.parent.relink (1, this.rightTree);
			wenn ((rightTree == Null) && (leftTree! = Null)) this.parent.relink (1, this.leftTree);
			this.leftTree = Null;
		}
		//At das Ende relink wir diesen Gegenstandhinweis auf dem Elternteil:
		this.parent = Null;
		Rückhol ausrichten;
	  } sonst {
	    /** Das noden hat zwei Kindnullpunkte, müssen diese richtig bewogen und unter den Elternteilnullpunkt richtig gesetzt *
		wenn (Wert <= this.parent.getValue ()) {//We sind auf der linken Seite, wir verbinden rechten Kindnullpunkt auf linker Seite am Elternteil
			//We bitten dann den rechten Kindnullpunkt, neuen Raum für das linke childnode zu finden
			this.parent.relink (0, this.rightTree);
			this.rightTree.giveNewPlace (this.leftTree);
			this.rightTree = Null;
			this.leftTree = Null;
			this.parent = Null;
		} sonst {//Or sonst sind wir auf der rechten Seite, und wir verbinden rechten Kindnullpunkt auf der rechten Seite am Elternteil
			this.parent.relink (1, this.rightTree);
			this.rightTree.giveNewPlace (this.leftTree);
			this.rightTree = Null;
			this.leftTree = Null;
			this.parent = Null;
		}
		this.parent = Null;
		Rückhol ausrichten;
	  }
	} sonst {
	//If haben wir nicht foumd der Nullpunkt mit dem korrekten Wert, suchen wir nach der korrekten Kindanmerkung und schauen dort:
	  wenn (this.value < Wert) {
	    wenn (rightTree! = Null) rightTree.deleteValue (Wert);
	  } sonst {
	    wenn (leftTree! = Null) leftTree.deleteValue (Wert);
	  }
	}
    Rückholfalsches;
  }
  allgemeines int getValue () {
    Rückholthis.value;
  }
  Öffentlichkeitslücke relink (int I, Unterbaum t) {
    wenn (i > 0) {
	  this.rightTree = t;
	} sonst {
	  this.leftTree = t;
	}
	t.setNewParent (dieses);
  }
  allgemeines Unterbaum getChildNode (int i) {
    wenn (i > 0) {
	  Rückholthis.rightTree;
	} sonst {
	  Rückholthis.leftTree;
	}
  }
  Öffentlichkeit leeres giveNewPlace (Unterbaum t) {
	//Takes-Unterbaum t und Versuche, zum ihm eines neuen Platzes im Baum zu geben
    //Check, wenn dieser Nullpunkt Raum für einen linken Kindnullpunkt hat, wenn nicht:
    //Check, wenn dieser Nullpunkt Raum für einen rechten Kindnullpunkt hat und die zwei korrekten childnodes bestellt, wenn nicht:
    //Ask das folgende linke childNode, zum des neuen Platzes mit seinem giveNewPlace zu geben ().
	wenn (this.leftTree == Null) {
		this.leftTree = t;
		t.setNewParent (dieses);
	} sonst, wenn (this.rightTree == Null) {
		wenn (getValue () < t.getValue ()) {
			this.rightTree = t;
			t.setNewParent (dieses);
		} sonst {
			this.rightTree = this.leftTree;
			this.leftTree = t;
			t.setNewParent (dieses);
		}
	} sonst {
		this.leftTree.giveNewPlace (t);
	}
  }
  Öffentlichkeit leeres setNewParent (Unterbaum t) {
	this.parent = t;
  }
  Öffentlichkeit leeres showObject () {
	System.out.println („----------------------------------------");
	wenn (Elternteil! = Null) System.out.println („Elternteil: “ + parent.getValue ());
    System.out.println („*Value: “ + this.value);
    wenn (rightTree! = Null) System.out.println („rechtes Kind: “ + rightTree.getValue ());
    wenn (leftTree! = Null) System.out.println („gelassenes Kind: “ + leftTree.getValue ());
	System.out.println („----------------------------------------");
  }
}

Kategorie BinarySeekingTree {
  private Unterbaumfäule;
  allgemeine toString Schnur () {
    wenn (Fäule! = Null) {
      Rückholrot.toString ();
    } sonst {
      Rückholnull;
    }
  }

  Öffentlichkeit leeres insertValue (int-Wert) {
    wenn (Fäule! = Null) {
      rot.insertValue (Wert);
    } sonst {
      Fäule = neuer Unterbaum (Wert, Null);
    }
  }
  
  allgemeines Boolesches deleteValue (int-Wert) {
	//If dort ist keine Wurzel im Baum, dann gibt es keinen zu löschenden Wert
    wenn (Fäule == Null) {
	  Rückholfalsches;
	} sonst {
	  wenn (rot.deleteValue (Wert)) {
	    Rückhol ausrichten;
	  } sonst {
	    Rückholfalsches;
	  }
	}
  }

  allgemeines Boolesches lookForValue (int søkeVerdi) {
    wenn (Fäule == Null) {
      Rückholfalsches;
    }
    Rückholrot.lookForValue (søkeVerdi);
  }
}

Kategorie Suchvorgang {
	allgemeine Staticlücke hauptsächlich (Schnur [] args) {
		BinarySeekingTree Baum = neues 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 („der Baum in einer sortierten Anzeige: “ + tree.toString ()); //Sorting fällt aus, nachdem es einen Gegenstand gelöscht hat
		System.out.println („ist 3 im Baum: “ + tree.lookForValue (3));
		System.out.println („ist 4 im Baum: “ + tree.lookForValue (4));
		System.out.println („ist 1 im Baum: “ + tree.lookForValue (1));
		System.out.println („ist 10 im Baum: “ + tree.lookForValue (10));
		System.out.println („ist 12 im Baum: “ + tree.lookForValue (12));
		System.out.println („ist 13 im Baum: “ + tree.lookForValue (13));
		System.out.println („ist 14 im Baum: “ + tree.lookForValue (14));
		System.out.println („ist 16 im Baum: “ + tree.lookForValue (16));
		System.out.println („ist 20 im Baum: “ + tree.lookForValue (20));
		System.out.println („ist 21 im Baum: “ + tree.lookForValue (21));
		System.out.println („ist 28 im Baum: “ + tree.lookForValue (28));
		System.out.println („ist 29 im Baum: “ + tree.lookForValue (29));
		System.out.println („ist 30 im Baum: “ + tree.lookForValue (30));
		System.out.println („ist 39 im Baum: “ + tree.lookForValue (39));
		System.out.println („wir versuchen jetzt, den Wert 10 aus dem Baum, aber nicht 28.") zu löschen;
		tree.deleteValue (10);
		//tree.deleteValue (28);
		System.out.println ("");
	System.out.println („der Baum in einer sortierten Anzeige: “ + tree.toString ()); //Sorting fällt aus, nachdem es einen Gegenstand gelöscht hat
		System.out.println („ist 3 im Baum: “ + tree.lookForValue (3));
		System.out.println („ist 4 im Baum: “ + tree.lookForValue (4));
		System.out.println („ist 1 im Baum: “ + tree.lookForValue (1));
		System.out.println („ist 10 im Baum: “ + tree.lookForValue (10));
		System.out.println („ist 12 im Baum: “ + tree.lookForValue (12));
		System.out.println („ist 13 im Baum: “ + tree.lookForValue (13));
		System.out.println („ist 14 im Baum: “ + tree.lookForValue (14));
		System.out.println („ist 16 im Baum: “ + tree.lookForValue (16));
		System.out.println („ist 20 im Baum: “ + tree.lookForValue (20));
		System.out.println („ist 21 im Baum: “ + tree.lookForValue (21));
		System.out.println („ist 28 im Baum: “ + tree.lookForValue (28));
		System.out.println („ist 29 im Baum: “ + tree.lookForValue (29));
		System.out.println („ist 30 im Baum: “ + tree.lookForValue (30));
		System.out.println („ist 39 im Baum: “ + tree.lookForValue (39));
	}
}

Antwort : Java-binärer Baum-logische Störungen

Ihr Code würde richtig arbeiten, wenn der Baum nach Auslassung ausgeglichen bleiben würde. Die Hauptursache Ihres Probleme wird unten erklärt:
Ist hier der linke Unterbaum, nachdem Sie den Nullpunkt mit Wert 10. entfernen.

                                            14
                                           /\
                                         3 12
                                        /\ \
                                      1 4 13

Wenn wir den Nullpunkt mit Wert 12 finden möchten, entsprechend Ihrem Code wird die 12 mit 14 verglichen. Wenn die 12 <� 14="">, zum des Probleme zu lösen Sie den Baum balanciert halten.
Weitere Lösungen  
 
programming4us programming4us