C5.1 : Les arbres binaires

Arborescence et arbres

Arborescence

De nombreuses situations de la vie courantes sont pensées sous forme d'arborescence :

Arborescence de dossiers et fichiers en mémoire
Arborescence de dossiers et fichiers en mémoire

Une structure de données a été conçue pour cela en informatique : les arbres.

Quelques définitions des arbres

Un arbre est une structure de données hiérarchique.

Un arbre est constitué de nœuds.

Les nœuds peuvent :

  • - avoir des nœuds enfants, aussi appelés sous-arbres ;
  • - ne pas avoir d'enfant (c'est-à-dire avoir des sous-arbres vides), le nœud est alors appelé une feuille.

Le nœud qui n'a pas de parent est appelé nœud racine ou simplement la racine.

Les nœuds peuvent tous (racine, nœuds avec enfants ou feuilles) stocker de l'information.

Applications

1) Proposer d'autres situations que celles du I.1 qui font appel à des arborescences.

2) Légender le schéma ci-dessous avec le vocabulaire des arbres.

Arborescence de dossiers et fichiers en mémoire

3) Comment sont appelées les feuilles dans une arborescence de dossiers et de fichiers ?

Les arbres binaires

Présentation

Un arbre binaire est un cas particulier d'arbre où chaque nœud peut :

  • - soit être vide ;
  • - soit avoir exactement deux sous-arbres (deux nœuds enfants) : le sous-arbre de gauche et le sous-arbre de droite.

Le nœud de départ d'un arbre est appelé la racine.

Lorsque les deux sous-arbres sont des arbres vides, le nœud est appelé une feuille.

Les nœuds (non vides) peuvent contenir de l'information.

Propriétés d'un arbre binaire

Taille d'un arbre

La taille d'un arbre binaire est le nombre de nœuds de cet arbre.

Profondeur d'un nœud

La profondeur d'un nœud est le nombre de nœuds du chemin qui va de la racine à ce nœud.

Propriété : La profondeur du nœud racine est égale à 1.

Hauteur d'un arbre

La hauteur d'un arbre est le plus grand nombre de nœuds rencontrés en partant de la racine et en allant jusqu'aux feuilles.

Propriété : L'arbre vide à une hauteur de 0.

Propriété : La hauteur d'un arbre est la plus grande profondeur de ces nœuds (non vides).

Remarque

Il existe une autre façon de définir la profondeur d'un nœud et la hauteur d'un arbre.

Dans cette autre vision, la profondeur de la racine est égale à 0.

Exercices

Exercice 1

Donner la taille et la hauteur des trois arbres représentés au II.1

Exercice 2 : Arbres binaires d'une taille donnée

1) Représenter tous les arbres binaires de taille 3. Donner la hauteur de chacun de ces arbres.

2) Représenter tous les arbres binaires de taille 4. Donner la hauteur de chacun de ces arbres.

Exercice 3 : Arbres binaires d'une hauteur donnée

1) Représenter tous les arbres binaires de hauteur 2.

2) Représenter tous les arbres binaires de hauteur 3.

Encadrement de la hauteur d'un arbre

Considérons un arbre de taille \(t\) et de hauteur \(h\).

1) Quelle est la plus petite taille \(t_{min}\) d'un arbre binaire de hauteur \(h\) ? En déduire une inégalité entre \(t\) et \(h\).

2) Quelle est la plus grande taille \(t_{max}\) d'un arbre binaire de hauteur \(h\) ? En déduire une inégalité entre \(t\) et \(h\)

3) En déduire un encadrement de la taille \(t\) d'un arbre en fonction de sa hauteur \(h\).

Afficher la correction

Arbre de hauteur h de plus petite taille

Comme c'est la plus petite taille possible : \(t \ge h\)

Arbre de hauteur h de plus grande taille

Comme c'est la plus grande taille possible : \(t \le 2^h-1\)

Données :

Implémentation en Python

Présentation

Il est possible d'implémenter les arbres binaires en utilisant des tuples.

Ainsi :

L'écriture en python de l'exemple A du II.1 sera : (2,(5,None,None),(8,None,(3,None,None))).

Applications

Quelques exemples d'arbres binaires en python

1) Donner les écritures en pythons des arbres binaires des exemples B et C du II.1.

2) Proposer deux arbres de votre choix avec l'écriture en python et la représentation graphique.

Détermination de la taille et de la hauteur d'un arbre

1) Écrire une fonction récursive qui renvoie la taille d'un arbre passée en paramètre.

2) Écrire une fonction récursive qui renvoie la hauteur d'un arbre passée en paramètre.

Afficher la correction
def taille(arbre):
    if arbre == None:
        return 0
    else:
        return 1 + taille(arbre[1]) + taille(arbre[2])

def hauteur(arbre):
    if arbre == None:
        return 0
    else:
        return 1 + max(hauteur(arbre[1]), hauteur(arbre[2]))

# ==== Programme principal ====
a = (2,(5,None,None),(8,None,(3,None,None)))
print("Taille : " + str(taille(a)))
print("Hauteur : " + str(hauteur(a)))