Utilisez deux méthodes pour y parvenir.
Méthode 1: parcourez l'arborescence binaire en séquence, enregistrez le nœud spécifié et revenez lorsque vous passez au nœud suivant
Complexité temporelle o (n)
Deuxième méthode:
1) Lorsque le nœud spécifié a un sous-arbre droit, retourne le premier nœud de traversée d'ordre moyen du sous-arbre droit
2) Lorsque le nœud spécifié n'a pas de sous-arbre droit, s'il s'agit du nœud gauche du nœud parent, le nœud parent est renvoyé
3) Lorsque le nœud spécifié n'a pas de sous-arbre droit et est le nœud droit de son nœud parent, il recherche toujours le nœud parent et revient lorsqu'un certain nœud parent est le nœud gauche de son nœud parent
Complexité temporelle o (logn)
Implémentation du code:
class BinNode:
def __init__(self, val, left=None, right=None, father=None):
self.val = val
self.left = left
self.right = right
if self.left:
self.left.father = self
if self.right:
self.right.father = self
self.father = father
def __str__(self):
return self.val
def no_traverse_next(target):
if target.right:
r = target.right
while r.left:
r = r.left
return r
f = target
ff = f.father
while f and ff:
if ff.left == f:
return ff
else:
f = ff
ff = ff.father
return None
def inorder_traverse_next(root, target):
prev, node, stack = None, root, []
while node or stack:
if node:
stack.append(node)
node = node.left
else:
n = stack.pop()
if n == target:
prev = n
if prev and n != target:
return n
node = n.right
return None
if __name__ == "__main__":
i = BinNode('i')
h = BinNode('h')
g = BinNode('g')
f = BinNode('f')
e = BinNode('e', h, i)
d = BinNode('d')
c = BinNode('c', f, g)
b = BinNode('b', d, e)
a = BinNode('a', b, c)
print(inorder_traverse_next(a, i))
print(inorder_traverse_next(a, b))
print(inorder_traverse_next(a, g))
print(no_traverse_next(i))
print(no_traverse_next(b))
print(no_traverse_next(g)
