Vous êtes sur la page 1sur 3

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

Code

N]

des entiers, val i,j, : entiers)

Procédure tri-select-ind-iter(ref tab: tableau [1 entiers) Var i,j,k : entiers Début

Pour i :=1 à n faire ind[i]=i FinPour

N]

des entiers, ref ind : tableau [1

i:=1

Tant que i<N faire j:=i;

N]des

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 : (N 2 ). 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

Fin Profondeur

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

Var k, nbfils : entier ;

Début

Si n = r

alors

sinon

retourner prof

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