Corrigé de l’examen écrit 2008-2009

Seuls les questions demandant le développement des algorithmes qui n’ont pas été vus en
cours sont corrigés

Question 1 : Tri

Considérons un tableau d’entiers T [1…N] et un tableau d’indices Ind[1…N].

En vous inspirant de l’algorithme de tri par sélection, proposez un algorithme de tri
laissant le tableau T inchangé, mais modifiant le tableau Ind de sorte qu’à la fin de
l’exécution Ind[i], i=1, …, N indique l’emplacement de l’ième élément dans le tableau
trié.
Evaluez la complexité de cet algorithme en utilisant la démarche de déduction par
récurrence. (5 pts)

Nous proposons un algorithme itératif sous forme d’une procédure.

Nous avons besoin d’une procédure effectuant des permutations des éléments d’un tableau
des entiers. Après son exécution le i-ème élément du tableau se trouve à la place du j-ème
élément et inversement.

Procédure échanger (ref t : tableau [1..N] des entiers, val i,j, : entiers)

Code

Procédure tri-select-ind-iter(ref tab: tableau [1..N] des entiers, ref ind : tableau [1..N]des
entiers)
Var i,j,k : entiers
Début
Pour i :=1 à n faire
ind[i]=i
FinPour

i:=1
Tant que i<N faire
j:=i;
Pour k:=i+1 à n faire {boucle de recherche de min }
Si tab[ind[k]]<tab[ind[j]]
j:=k
FinSi
FinPour
échanger(ind, j,i);
i:=i+1;
FinTantque
Fin tri-select-iter-ind
La complexité de cet algorithme est quadratique : θ(N2).
En effet, pour rechercher le minimum dans la partie non-triée du tableau à la première
itération il est nécessaire d’effectuer N-1 comparaisons, à la deuxième itération – N-2 etc..

T ( N ) = N − 1 + N − 2 + ... + 1 = N ( N − 1) / 2

Question 2 : Arbres Génériques

Soit A un arbre générique de racine r et de degré maximal de ses sommets d. On se

propose de représenter cet arbre par la structure de données comprenant pour chaque
nœud la liste de ses fils sous la forme d’un tableau des pointeurs.

2.3. En utilisant le parcours de l’arbre en ordre préfixe, écrivez une fonction récursive de
calcul de la profondeur d’un sommet n en langage ExAlgo.
La signature de la fonction est :

Fonction Profondeur(PtrNoeud : r, PtrNoeud n) : entier ;

Nous proposons un algorithme récursif de calcul de la profondeur du sommet d’un arbre

générique par parcours en ordre préfixe, en langage ExAlgo.

Conformément à la représentation de l’arbre par la structure de données comprenant pour

chaque nœud la liste de ses fils sous forme d’un tableau nous allons définir un type Liste
comme

Type Liste : tableau[1...N] de PtrNoeud.

Nous allons également avoir besoin des fonctions suivantes :

Fonction ProfondeurAux(r : PtrNoeud , n : PtrNoeud, Val entier : prof) : entier ;

{C’est une fonction auxilière nécessaire pour un algorithme récursif}
Fonction NombreFils(r : PtrNoeud) : entier ;
{Cette fonction renvoie le nombre de fils d’un nœud}
Fonction ListeFils(r : PtrNoeud) : Liste ;
{cette fonction renvoie le pointeur sur la liste des fils du nœud r}
Fonction Ième(l : Liste, Val entier : i) : PtrNoeud ;
{Cette fonction renvoie le pointeur sur l’ième élément de la liste}

Code en ExAlgo

Fonction Profondeur(r : PtrNoeud , n : PtrNoeud) : entier ;

{C’est la fonction principale}

Fonction Profondeur(r : PtrNoeud , n : PtrNoeud) : entier

Début
retourner ProfondeurAux(r, n, 0)
Fin Profondeur

Fonction ProfondeurAux(r : PtrNoeud , n : PtrNoeud, Val prof : entier) : entier

Var k, nbfils : entier ;

Début

Si n = r
alors
retourner prof
sinon
nbfils = NombreFils(r)
Si nbfils = 0
alors
retourner –1 ; { Traitement terminal }
sinon
Pour i = 1, …, nbfils faire
k = ProfondeurAux(Ième(ListeFils(r), i), n, prof +
1)
Si k ≠ -1
alors retourner k
Fin Si
Fin Pour
retourner –1 ; { Nécessaire si le sommet n n’est pas dans l’arbre
}
Fin Si
Fin Si

Fin ProfondeurAux