Bij het verwijderen van een knooppunt met twee kinderen, kunt u ervoor kiezen de in-order opvolgerknooppunt of de in-order voorganger node. In dit geval is het vinden van de grootste waarde in het linker subboom (dat wil zeggen de meest rechtse kind van zijn linker subboom), wat betekent dat het vinden van het knooppunt in orde vorige knooppunt.
Zodra u de vervangende knooppunt te vinden, je eigenlijk niet te verwijderen het knooppunt te worden verwijderd. In plaats daarvan u de waarde van de opvolger knooppunt te nemen en op te slaan die waarde in het knooppunt dat u wilt verwijderen. Dan moet je de opvolger knooppunt verwijderen. In doen, zodat u de binary search-boom eigendomsrechten te beschermen want je kunt er zeker van zijn dat het knooppunt u gekozen voor een waarde die lager is dan de waarden van alle kinderen in de linker sub-boom van de oorspronkelijke node zal hebben, en groter dan dan de waarden van alle kinderen in de juiste sub-boom van de oorspronkelijke node.
BEWERK
Na het lezen van uw vraag een beetje meer, ik denk dat ik het probleem gevonden.
Typisch wat u in aanvulling op de deletefunctie is een replacefunctie die de knoop in kwestie vervangt. Ik denk dat je nodig hebt om deze regel code te wijzigen:
FindParent(largestValue).Right <- 0
naar:
FindParent(largestValue).Right <- largestValue.Left
Als het largestValueknooppunt een linker kind heeft, je gewoon krijgen nullof 0. Als het heeft een linkse kind, dat kind wordt een vervanger voor de largestValuenode. Dus je hebt gelijk; de code geen rekening wordt gehouden met het scenario dat het largestValueknooppunt een linker kind zou kunnen hebben.
Een andere EDIT
Aangezien u slechts hebt gepost een fragment, ik weet niet zeker wat de context van de code is. Maar het fragment zoals gepubliceerd lijkt om het probleem dat u suggereren (ter vervanging van de verkeerde knooppunt) te hebben. Meestal zijn er drie gevallen, maar ik merk dat het commentaar in uw fragment zegt //Case 4(dus misschien is er een andere context).
Eerder heb ik gezinspeeld op het feit dat deletemeestal wordt geleverd met een replace. Dus als je het gedeelte van largestValueknooppunt u deze verwijderen volgens de twee eenvoudige gevallen (knooppunt zonder kinderen, en het knooppunt met een kind). Dus als u op zoek bent naar pseudo-code om een knooppunt met twee kinderen te verwijderen, dit is wat je gaat doen:
get largestValue from nodeToRemove.Left
nodeToRemove.Value <- largestValue.Value
//now replace largestValue with largestValue.Left
if largestValue = largestValue.Parent.Left then
largestValue.Parent.Left <- largestValue.Left //is largestValue a left child?
else //largestValue must be a right child
largestValue.Parent.Right <- largestValue.Left
if largestValue.Left is not null then
largestValue.Left.Parent <- largestValue.Parent
Ik vind het vreemd dat een computer algoritmes en datastructuren boek zou vertrekken uit dit deel, dus ik ben geneigd te denken dat het boek heeft verder opgesplitst het verwijderen in een paar gevallen (omdat er drie standaard gevallen) om het gemakkelijker te maken begrijpen.
Om te bewijzen dat de bovenstaande code werkt, overweeg dan de volgende boom:
8
/ \
7 9
Laten we zeggen dat u wilt verwijderen 8. Je probeert te vinden largestValueuit nodeToRemove.Left. Dit geeft u 7, omdat de linker sub-boom heeft slechts één kind.
Dan denk je:
nodeToRemove.Value <- largestValue.Value
Wat betekent:
8.value <- 7.Value
of
8.Value <- 7
Dus nu uw boom ziet er als volgt uit:
7
/ \
7 9
Je moet om zich te ontdoen van de vervangende knooppunt en dus je gaat vervangen largestValuemet largestValue.Left(wat null). Dus eerst kom je erachter wat voor soort kind 7is:
if largestValue = largestValue.Parent.Left then
Wat betekent:
if 7 = 7.Parent.Left then
of:
if 7 = 8.Left then
Daar 7wil 8linker kind, moet vervangen 8.Leftmet 7.Right( largestValue.Parent.Left <- largestValue.Left). Daar 7heeft geen kinderen, 7.Leftis nul. Dus largestValue.Parent.Leftwordt toegewezen aan null (die effectief verwijdert zijn linker kind). Dit betekent dus dat je eindigt met de volgende boom:
7
\
9
