Pytanie : Jawa Binarny Drzewny Logiczny Błąd

I zawierać tutaj the kod dla binarny drzewo. Tam  być kilka problem z the kod. The drzewo być pusty najpierw, then wartość wkładać. The pierwszy wartość być przy the wierzchołek. The następny wartość być na the pierwszy wartość lewa strona jeżeli ono być mały wtedy the pierwszy wartość. Ono umieszczać na the prawa strona jeżeli ono być wielki wtedy the początkowy wartość. Ten wartość być the pierwszy wartość dziecko guzek, i the pierwszy wartość być swój rodzic. Gdy wartość miewać lewica i prawy dziecko guzek, tamte guzek znowu tworzyć nowy dziecko guzek the ten sam logika gdy nowy wartość wkładać w the drzewo. W ten przykład I używać the wartość (1) 3 4 10 12 13 14 15 16 20 21 28 29 30 39. I wtedy kasować wartość 10, i widzieć jeżeli I móc re-arrange the drzewo prawidłowo. The początkowy drzewo przypuszczać jak w postać A.

1) Gdy I kasować the guzek z wartość 10 I podążać the logika wystawiać w postać B. Liczba wydawać się LICZBA, i wszystkie the liczba który zostawać wystawiać, ale gdy gmeranie dla wszystkie the wartość, the mechanizm wydawać się że liczba the liczba brakować. Zaraz po pozycja w rozkaz. Przykład:

" The drzewo w ułożony pokaz: (1) 3 4 14 12 13 15 16 20 21 28 29 30 39
Is 3 w the drzewo: true
Is 4 w the drzewo: true
Is (1) w the drzewo: true
Is 10 w the drzewo: false
Is 12 w the drzewo: false
Is 13 w the drzewo: false
Is 14 w the drzewo: true
Is 16 w the drzewo: true
Is 20 w the drzewo: true
Is 21 w the drzewo: true
Is 28 w the drzewo: true
Is 29 w the drzewo: true
Is 30 w the drzewo: true
Is 39 w the drzewo: prawdziwy "

This zdarzać się tylko gdy kasować 10 (lewa strona dziecko guzek), ale nie 28 (prawa strona dziecko guzek).

2) The rozkaz the liczba wydawać się żonglować wokoło po skasowanie. I biedak być sprawnie sprawnie dlaczego. Po guzek z wartość 10, I dostawać ten rozkaz: (1) 3 4 14 12 13 15 16 20 21 28 29 30 39
Here ty móc że 14 umieszczać źle. To zdarzać się gdy kasować guzek z wartość 28.

Figure A:
FigA.png (21 KB) (Kartoteka Typ Szczegół)
Figure A
323583


Figure B:
FigB.png (27 KB) (Kartoteka Typ Szczegół)
Figure B
323584


When prawa strona guzek:
We początek skasowanie 28.
A) 29 brać 28's place.
B) My pytać guzek przy 29 nowy przestrzeń dla 20.

Then my symulować skasowanie 10.
I) 14 brać 10 place.
II) My pytać 14 nowy przestrzeń dla 3.

The logika być the 14 w oba przykład, tylko różny strona dawać guzek (w zależności od jaki strona the guzek być na, kasować). 
(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 SubTree {
  intymny SubTree rightTree = null;
  intymny SubTree leftTree = null;
  intymny SubTree rodzic = null;
  intymny int wartość = (0);

  jawny SubTree (int wartość) {
    this.value = wartość;
  }

  jawny SubTree (int wartość, SubTree rodzic) {
    this.value = wartość;
    this.parent = rodzic;
  }

  jawny kawitacyjny insertValue (int newValue) {
    jeżeli (wartość >= newValue) {
      jeżeli (leftTree! = null) {
        leftTree.insertValue (newValue);
      } inny {
        leftTree = nowy SubTree (newValue, to);
      }
    } inny {
      jeżeli (rightTree! = null) {
        rightTree.insertValue (newValue);
      } inny {
        rightTree = nowy SubTree (newValue, to);
      }
    }
  }

  społeczeństwo Sznurek toString () {
    Smyczkowy returString = "";
    jeżeli (leftTree! = null) {
      returString = leftTree.toString () + "";
    }
    returString = returString + wartość;
    jeżeli (rightTree! = null) {
      returString = returString + ""+ rightTree.toString ();
    }
	showObject ();
    powrotny returString;
  }

  jawny jawny lookForValue (int søkeVerdi) {
    jeżeli (søkeVerdi == wartość) {
      powrót prawdziwy;
    }
    jeżeli (wartość > søkeVerdi) {
      jeżeli (leftTree! = null) {
        powrotny leftTree.lookForValue (søkeVerdi);
      } inny {
        powrotny fałszywy;
      }
    } inny {
      jeżeli (rightTree! = null) {
        powrotny rightTree.lookForValue (søkeVerdi);
      } inny {
        powrotny fałszywy;
      }
    }
  }
  
  jawny jawny deleteValue (int wartość) {
    jeżeli (this.value == wartość) {
	//If my znajdować guzek z prawy wartość, my musieć jeżeli ono mieć jakaś dziecko guzek
	  jeżeli ((rightTree == null) && (leftTree == null)) {
	    /** Ten guzek mieć żadny dziecko, ono móc łączyć z the tree.*/
		jeżeli (wartość <= this.parent.getValue ()) {//We być na lewa strona, i my relink tam  przy the rodzic
			this.parent.relink ((0), null);
		} inny {//We być na the prawa strona, i my relink tam  przy the rodzic
			this.parent.relink ((1), null);
		}
		//At the końcówka my relink ten przedmiot backreference rodzic:
		this.parent = null;
		powrót prawdziwy;
	  } inny jeżeli (((rightTree == null) && (leftTree! = null)) || ((rightTree! = null) && (leftTree == null))) {
	    /** The guzek mieć tylko jeden dziecko guzek. My łączyć nad ten guzek the dziecko *
		jeżeli (wartość <= this.parent.getValue ()) {//We być na lewa strona, i my łączyć tam  nad ten przedmiot ten przedmiot rightTree
			jeżeli ((rightTree! = null) && (leftTree == null)) this.parent.relink ((0), this.rightTree);
			jeżeli ((rightTree == null) && (leftTree! = null)) this.parent.relink ((0), this.leftTree);
			this.rightTree = null;
		} inny {//Or inny my być na the prawa strona, i my łączyć tam  nad ten przedmiot ten przedmiot leftTree
			jeżeli ((rightTree! = null) && (leftTree == null)) this.parent.relink ((1), this.rightTree);
			jeżeli ((rightTree == null) && (leftTree! = null)) this.parent.relink ((1), this.leftTree);
			this.leftTree = null;
		}
		//At the końcówka my relink relink protestować odniesienie the rodzic:
		this.parent = null;
		powrót prawdziwy;
	  } inny {
	    /** The noden mieć dwa dziecko guzek, dwa musieć prawidłowo i prawidłowo pod the mateczny guzek *
		jeżeli (wartość <= this.parent.getValue ()) {//We być na the lewa strona, my łączyć prawy dziecko guzek na lewa strona przy the rodzic
			//We wtedy pytać the prawy dziecko guzek nowy przestrzeń dla the lewy childnode
			this.parent.relink ((0), this.rightTree);
			this.rightTree.giveNewPlace (this.leftTree);
			this.rightTree = null;
			this.leftTree = null;
			this.parent = null;
		} inny {//Or inny my być na the prawa strona, i my łączyć prawy dziecko guzek na the prawa strona przy the rodzic
			this.parent.relink ((1), this.rightTree);
			this.rightTree.giveNewPlace (this.leftTree);
			this.rightTree = null;
			this.leftTree = null;
			this.parent = null;
		}
		this.parent = null;
		powrót prawdziwy;
	  }
	} inny {
	//If my biedak foumd the guzek z the poprawny wartość, my szukać the poprawny dziecko notatka i patrzeć tam:
	  jeżeli (this.value < wartość) {
	    jeżeli (rightTree! = null) rightTree.deleteValue (wartość);
	  } inny {
	    jeżeli (leftTree! = null) leftTree.deleteValue (wartość);
	  }
	}
    powrotny fałszywy;
  }
  jawny int getValue () {
    powrotny this.value;
  }
  jawny pustka relink (int i, SubTree t) {
    jeżeli (i > (0)) {
	  this.rightTree = t;
	} inny {
	  this.leftTree = t;
	}
	t.setNewParent (to);
  }
  jawny SubTree getChildNode (int i) {
    jeżeli (i > (0)) {
	  powrotny this.rightTree;
	} inny {
	  powrotny this.leftTree;
	}
  }
  jawny kawitacyjny giveNewPlace (SubTree t) {
	//Takes SubTree t i próba ono nowy miejsce w the drzewo
    //Check jeżeli ten guzek mieć przestrzeń dla lewy dziecko guzek, jeśli nie:
    //Check jeżeli ten guzek mieć przestrzeń dla prawy dziecko guzek i rozkazywać the dwa childnodes poprawny, jeśli nie:
    //Ask the następny lewy childNode nowy miejsce z swój giveNewPlace ().
	jeżeli (this.leftTree == null) {
		this.leftTree = t;
		t.setNewParent (to);
	} inny jeżeli (this.rightTree == null) {
		jeżeli (getValue () < t.getValue ()) {
			this.rightTree = t;
			t.setNewParent (to);
		} inny {
			this.rightTree = this.leftTree;
			this.leftTree = t;
			t.setNewParent (to);
		}
	} inny {
		this.leftTree.giveNewPlace (t);
	}
  }
  jawny kawitacyjny setNewParent (SubTree t) {
	this.parent = t;
  }
  jawny kawitacyjny showObject () {
	System.out.println ("----------------------------------------");
	jeżeli (rodzic! = null) System.out.println ("Rodzic: " + parent.getValue ());
    System.out.println ("*Value: " + this.value);
    jeżeli (rightTree! = null) System.out.println ("Prawy dziecko: " + rightTree.getValue ());
    jeżeli (leftTree! = null) System.out.println ("Opuszczać dziecko: " + leftTree.getValue ());
	System.out.println ("----------------------------------------");
  }
}

klasowy BinarySeekingTree {
  intymny SubTree spróchniałość;
  społeczeństwo Sznurek toString () {
    jeżeli (spróchniałość! = null) {
      powrotny rot.toString ();
    } inny {
      powrotny null;
    }
  }

  jawny kawitacyjny insertValue (int wartość) {
    jeżeli (spróchniałość! = null) {
      rot.insertValue (wartość);
    } inny {
      spróchniałość = nowy SubTree (wartość, null);
    }
  }
  
  jawny jawny deleteValue (int wartość) {
	//If tam  być żadny korzeń w the drzewo, then tam  być żadny wartość
    jeżeli (gnilny == null) {
	  powrotny fałszywy;
	} inny {
	  jeżeli (rot.deleteValue (wartość)) {
	    powrót prawdziwy;
	  } inny {
	    powrotny fałszywy;
	  }
	}
  }

  jawny jawny lookForValue (int søkeVerdi) {
    jeżeli (gnilny == null) {
      powrotny fałszywy;
    }
    powrotny rot.lookForValue (søkeVerdi);
  }
}

klasowy Aport {
	jawny statyczny kawitacyjny główny (Sznurek [] args) {
		BinarySeekingTree drzewo = nowy 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 ("The drzewo w ułożony pokaz: " + tree.toString ()); //Sorting nie udać się po przedmiot
		System.out.println ("Być 3 w the drzewo: " + tree.lookForValue (3));
		System.out.println ("Być 4 w the drzewo: " + tree.lookForValue (4));
		System.out.println ("Być (1) w the drzewo: " + tree.lookForValue (1));
		System.out.println ("Być 10 w the drzewo: " + tree.lookForValue (10));
		System.out.println ("Być 12 w the drzewo: " + tree.lookForValue (12));
		System.out.println ("Być 13 w the drzewo: " + tree.lookForValue (13));
		System.out.println ("Być 14 w the drzewo: " + tree.lookForValue (14));
		System.out.println ("Być 16 w the drzewo: " + tree.lookForValue (16));
		System.out.println ("Być 20 w the drzewo: " + tree.lookForValue (20));
		System.out.println ("Być 21 w the drzewo: " + tree.lookForValue (21));
		System.out.println ("Być 28 w the drzewo: " + tree.lookForValue (28));
		System.out.println ("Być 29 w the drzewo: " + tree.lookForValue (29));
		System.out.println ("Być 30 w the drzewo: " + tree.lookForValue (30));
		System.out.println ("Być 39 w the drzewo: " + tree.lookForValue (39));
		System.out.println ("My teraz próbować the wartość 10 od the drzewo, ale nie 28.");
		tree.deleteValue (10);
		//tree.deleteValue (28);
		System.out.println ("");
	System.out.println ("The drzewo w ułożony pokaz: " + tree.toString ()); //Sorting nie udać się po przedmiot
		System.out.println ("Być 3 w the drzewo: " + tree.lookForValue (3));
		System.out.println ("Być 4 w the drzewo: " + tree.lookForValue (4));
		System.out.println ("Być (1) w the drzewo: " + tree.lookForValue (1));
		System.out.println ("Być 10 w the drzewo: " + tree.lookForValue (10));
		System.out.println ("Być 12 w the drzewo: " + tree.lookForValue (12));
		System.out.println ("Być 13 w the drzewo: " + tree.lookForValue (13));
		System.out.println ("Być 14 w the drzewo: " + tree.lookForValue (14));
		System.out.println ("Być 16 w the drzewo: " + tree.lookForValue (16));
		System.out.println ("Być 20 w the drzewo: " + tree.lookForValue (20));
		System.out.println ("Być 21 w the drzewo: " + tree.lookForValue (21));
		System.out.println ("Być 28 w the drzewo: " + tree.lookForValue (28));
		System.out.println ("Być 29 w the drzewo: " + tree.lookForValue (29));
		System.out.println ("Być 30 w the drzewo: " + tree.lookForValue (30));
		System.out.println ("Być 39 w the drzewo: " + tree.lookForValue (39));
	}
}

Odpowiedź : Jawa Binarny Drzewny Logiczny Błąd

Twój kod pracować stosownie jeżeli the drzewo zostawać zrównoważony po skasowanie. The główny przyczyna twój problem wyjaśniać twój:
Tutaj być the lewy subtree po tym jak ty usuwać the guzek z wartość 10.

                                            14
                                           /\
                                         3 12
                                        /\ \
                                      (1) 4 13

Jeżeli my chcieć the guzek z wartość 12, według twój kod the 12 porównywać z 14. Jeżeli the 12 <� 14="">The problem ty musieć utrzymywać the drzewo.
Inne rozwiązania  
 
programming4us programming4us