None. Cela simplifie la récursivité, le cas deif noeud is None: return ....]]>[valeur, gauche, droite]]]>valeur, gauche, droit]]>gauche et droit valent soitNone, soit un autre nœud. Exemple :
class Noeud:
def __init__(self, v, g=None, d=None):
self.valeur = v
self.gauche = g
self.droit = ddef h(n):
return 1 + max(h(n.gauche), h(n.droit))]]>n.gauche est alors évalué sur None, ce quiAttributeError.]]>def h(n):
if n is None: return 0
return 1 + h(n.gauche) + h(n.droit)]]>def h(n):
if n is None: return -1
return max(h(n.gauche), h(n.droit))]]>1 +, rien ne compte lesdef h(n):
if n is None: return -1
return 1 + max(h(n.gauche), h(n.droit))]]>print par rapportdef parcours(n):
if n is None: return
print(n.valeur)
parcours(n.gauche)
parcours(n.droit)]]>def parcours(n):
print(n.valeur)
parcours(n.gauche)
parcours(n.droit)]]>if n is None: return. L'appel finit parNone et lèveAttributeError avant la fin du parcours.]]>def parcours(n):
if n is None: return
parcours(n.gauche)
parcours(n.droit)
print(n.valeur)]]>def parcours(n):
if n is None: return
parcours(n.gauche)
print(n.valeur)
parcours(n.droit)]]>Noeud, un sous-arbreNone :class Noeud:
def __init__(self, valeur, gauche, droit):
self.valeur = valeur
self.gauche = gauche
self.droit = droit
def somme(arbre):
if arbre is None:
return 0
return arbre.valeur + somme(arbre.gauche) + somme(arbre.droit)
a = Noeud(5, Noeud(3, None, Noeud(4, None, None)), Noeud(8, None, None))somme(a) ?]]>20]]>12]]>arbre.valeur pour chaque nœud interne, ici $5$ et $3$.]]>16]]>None]]>if arbre is None traite justement lesarbre.valeur.]]>def parcours_largeur(racine):
if racine is None:
return
f = [racine]
while len(f) > 0:
n = f.pop(0)
print(n.valeur)
if n.gauche is not None:
f.append(n.gauche)
if n.droit is not None:
f.append(n.droit)list avec append et pop(0))]]>pop(0) retire le premier élément) etlist avec append et pop)]]>def miroir(n):
if n is None: return
n.gauche, n.droit = n.droit, n.gauche
miroir(n.gauche)
miroir(n.droit)Noeud habituelle (attributs valeur, gauche etdroit, un sous-arbre vide valant None), cette fonction teste sidef egaux(a, b):
if a is None and b is None:
return True
if a is None or b is None:
return False
return (a.valeur == b.valeur and egaux(a.gauche, b.gauche)
and egaux(a.droit, b.droit))Que se passe-t-il si l'on supprime le second test,
if a is None or b is None, et la ligne qui le suit ?
None, ce qui provoque unea.valeur == b.valeurNone d'un côté.]]>True, les formes n'étant plus comparées]]>Falsea vaut None et pas b, ou l'inverse, levaleur de None, ceAttributeError. Si une différence de valeur est repéréeand s'arrête et la fonction renvoie False sans erreur.]]>RecursionError]]>None → $0$, cas récursif $1 + $ somme desdef taille(n):
if n is None:
return 0
return 1 + max(taille(n.gauche), taille(n.droit))]]>def taille(n):
if n is None:
return 0
return 1 + taille(n.gauche) + taille(n.droit)]]>def taille(n):
if n is None:
return 1
return taille(n.gauche) + taille(n.droit)]]>None) au lieu des nœuds. La taille d'undef taille(n):
if n is None:
return 0
return taille(n.gauche) + taille(n.droit)]]>1 +). La somme se réduitn.gauche is None and n.droit is None. C'est unetaille, qui se contente d'additionner sansdef feuilles(n):
if n is None:
return 1
return feuilles(n.gauche) + feuilles(n.droit)]]>None), ce qui donne le double du nombre dedef feuilles(n):
if n is None:
return 0
return feuilles(n.gauche) + feuilles(n.droit)]]>def feuilles(n):
if n is None:
return 0
return 1 + feuilles(n.gauche) + feuilles(n.droit)]]>def feuilles(n):
if n is None:
return 0
if n.gauche is None and n.droit is None:
return 1
return feuilles(n.gauche) + feuilles(n.droit)]]>cible dans un arbre binaire-1 si la valeur n'est pas présente) ?]]>(nœud, profondeur). Permet d'éviter laO(n) au pire, où n est le nombre de nœuds.]]>def profondeur(n, cible):
if n is None:
return -1
if n.valeur == cible:
return 0
g = profondeur(n.gauche, cible)
if g != -1:
return g + 1
return 1 + profondeur(n.droit, cible)]]>-1.]]>def profondeur(n, cible):
if n.valeur == cible:
return 0
return 1 + profondeur(n.gauche, cible)]]>None sans avoir trouvé la cible.def profondeur(n, cible):
if n is None:
return 0
if n.valeur == cible:
return 1
return profondeur(n.gauche, cible) + profondeur(n.droit, cible)]]>def profondeur(n, cible, p=0):
if n is None:
return -1
if n.valeur == cible:
return p
g = profondeur(n.gauche, cible, p + 1)
if g != -1:
return g
return profondeur(n.droit, cible, p + 1)]]>p, qu'on incrémentep-1), on-1 (cible(gauche, valeur, droit),None. Que vaut a[2][1] ?a = ((None, 2, None), 5, (None, 8, None))8, la valeur du fils droit]]>a[2] est le sous-arbre droit(None, 8, None), et son élément d'indice $1$ est sa8.]]>5, la valeur de la racine]]>a[1].]]>2, la valeur du fils gauche]]>a[0].]]>a[2] est lui-même un tuple, on peut l'indexer à sonNoeud avec les attributsvaleur, gauche et droit, un sous-arbre vide étant None.n est une feuille ?]]>n.gauche is None and n.droit is None]]>n.gauche is None or n.droit is None]]>n.valeur is None, la feuille ne portant rien]]>n is None, le nœud étant au bout de l'arbre]]>None est l'arbre vide, pas une feuille.]]>Noeud dontNone ?def compte(a):
if a is None:
return 0
n = compte(a.gauche) + compte(a.droit)
if a.gauche is not None and a.droit is not None:
n = n + 1
return nNone, elle n'ajouteA. Son fils gauche B a deux enfants,D à gauche et E à droite. Son fils droit C a unF, à gauche. Quel est le parcours infixe ?]]>D B E A F C]]>D B E,A, puis F C.]]>A B D E C F]]>D E B F C A]]>A B C D E F]]>A B C et pour parcours infixe B A C. Quel estA, fils gauche B, fils droit C]]>A ; dansA est à gauche, B, et ce quiC.]]>B, fils gauche A, fils droit C]]>A.]]>A, fils gauche C, fils droit B]]>C avant A.]]>C, fils gauche B, fils droit A]]>C est le dernier du préfixe, il ne peut pas être