Td n1 : algorithmique et structure des données

Série N°1 :Algorithmes itératifs

Exercice 3 :
1.
Maximum(A)
max ← A[1]
pour i ← 2 a n faire
si max ¡ A[i] alors max ← A[i]
renvoyer max
2. la complexité en nombre de comparaisons : n – 1
3. Tout ´élément hormis le maximum doit avoir perdu une comparaison, sinon, on ne peut
pas savoir qu’il
n’est pas le maximum. Il y a n − 1 tels ´éléments. Tout algorithme de recherche du maximum
doit donc faire au moins n − 1 comparaison

exercice 4 :
1.
Maximum-et-Minimum(A)
max ← A[1]
pour i ← 2 `a n faire
si max != A[i] alors max ← A[i]
min ← A[1]
pour i ← 2 `a n faire
si min != A[i] alors min ← A[i]
renvoyer max et min

2. Cet algorithme effectue 2n − 2 comparaisons.

3.
Maximum-et-Minimum(A)
Pour i ← 1 `a n − 1 faire par pas de 2
si A[i] > A [i + 1] alors échanger A[i] et A[i + 1]
min ← A[1]
Pour i ← 3 `a n faire par pas de 2
si A[i] < min alors min ← A[i]
max ← A[2]
Pour i ← 4 `a n faire par pas de 2
si A[i] > max alors max ← A[i]
si n est impair alors si A[n] > max alors max ← A[n]
renvoyer max et min
4.

(a) On peut former paires, on effectue donc comparaisons.

(b) Parmi n éléments on a éléments de rangs impairs. Dans cette phase on effectue
donc -1 comparaisons.

(c) Ici aussi on effectue aussi − 1 comparaisons. D’où une complexité totale en :

T(n) = +2 − 1 = 𝑛 + ⌊𝑛/2⌋ − 2

Exercice5 :
1.
Deuxième-Plus-Grand (A)
rang max ← 1
pour i ← 2 `a n faire si A[rang max] ¡ A[i] alors rang max ← i
si rang max 6= 1 alors rang second ← 1
sinon rang second ← 2
pour i ← 2 `a n faire si i 6= rang max et A[rang second] ¡ A[i] alors rang second ← i
renvoyer A[rang second]
2.
La recherche du maximum coute n − 1 comparaisons. La boucle qui recherche le deuxième
plus grand
élément une fois que le maximum a ´t’ trouvé effectue n−2 comparaisons. D’où un cout total
de 2n−3 comparaisons.
3.
Les comparaisons sont organisées comme dans un tournoi :
– Dans une première phase, les valeurs sont comparées par paires. Dans chaque paire, il y a
bien sûr un plus grand ´élément (le « vainqueur ») et un plus petit ´élément (le « vaincu »).
– Dans la deuxième phase, les valeurs qui ´étaient plus grand ´élément de leur paire `a la
phase précédente sont comparées entres elles deux a deux.
– On répète ce processus jusqu’au moment où il n’y a plus qu’un plus grand ´élément.

4.
Le deuxième plus grand n’est plus petit que devant le plus grand élément. Il n’a donc « perdu » que
dans une comparaison, celle avec le plus grand élément.

5.
Le deuxième plus grand élément est donc un des éléments qui ont été battus par le plus grand
élément.

L’algorithme a lieu en deux phases :

(a) On recherche tout d’abord le plus grand élément suivant la méthode du tournoi.

(b) On obtient le deuxième plus grand ´élément en recherchant l’élément maximal parmi ceux qui
ont été éliminés du tournoi lors d’une comparaison avec l’élément maximal.

6.

La recherche de l’´élément maximal coûte n − 1 comparaisons, comme d’habitude. Ensuite la

recherche du deuxième plus grand ´élément nous coûte m − 1 comparaisons, où m est le nombre
d’´éléments `a qui l’´élément maximal a ´t’ compare. Dans le pire cas 1 , m est ´égal `à la hauteur de
l’arbre moins 1 (un arbre réduit `a sa racine ´étant de hauteur un). Or un arbre binaire presque
parfait à n feuilles est de hauteur 𝑙𝑜𝑔2( 𝑛). D’où la complexité :

𝑇(𝑛) = 𝑛 + log 𝑛 − 2
 Série d'exercices N° 2
Récursivité
Exercice3 :
1.
Test(X):
i=0
tant que i < taille(X)-1 faire
si X[i]>X[i+1]:
affiche Faux
i=i+1
affiche vraie
fin test
2.

Exercice5 :
1.
binaire(N):
si N<=1:
retourne chaine(N)
sinon :
retourne binaire(N//2)+chaine (N%2)
2.
𝑛 𝑛
𝐶(𝑁) = 1 + 3 + 𝐶 = 4 + 𝐶
2 2
𝐶(0) = 𝐶(1) = 1
𝑂𝑛 𝑝𝑜𝑠𝑒 𝑖 = 𝑙𝑜𝑔2(𝑁); 𝑜𝑛 𝑎 𝑇 (𝑖) = 4 + 𝑇 (𝑖 − 1)
𝑇(𝑖) = 4𝑖 + 𝑇 (0) = 𝑂(𝑖)
𝐷𝑜𝑛𝑐 𝐶(𝑁) = 𝑂(𝑙𝑜𝑔2(𝑁))
Exercice6 :palindrome
1.
Fonction palindrome(mot : Chaîne de caractères) : entier
Var n : Entier;
Début
n ← long(mot)
//Un mot de longueur 0 est un palindrome, et ce sera notre cas de base
Si(n=0) :
Alors Renvoyer(1)
//Si la première et la dernière lettres coïncident, on les efface et on vérifie que le mot
//restant est aussi un palindrome
Sinon :
Si (mot[0]=mot[n-1]) :
Alors Renvoyer(palindrome(sous_chaine(mot,1,n-2)))
//Si ces deux lettres sont différentes, le mot n'est pas un palindrome
Sinon
Renvoyer(0)
FinSi
Fin.
2.complexite
Exercice9 :suite de Fibonacci
1.
Fonction fibo(n : Entier) : Entier
Début
Si(n≤ 1) :
Alors Renvoyer(1)
Sinon :
Renvoyer (fibo(n-1)+fibo(n-2))
FinSi
Fin .
2. On procède par récurrence. On veut montrer qu’il existe une constante c strictement
positive telle que T(n) ≥ c.2n pour des valeurs de n supérieures a une certaine borne n0 (a
déterminer). Supposons le Résultat démontre jusqu’au rang n − 1. Alors :

𝑇(𝑛) = 𝑇(𝑛 − 1) + 𝑇(𝑛 − 2) + 1 ≥ 𝑐. 2 + 𝑐. 2 +1

/
≥ 𝑐. 2 + 𝑐. 2 + 1 ≥ 2 . 𝑐. 2 = 𝑐. 2

Il nous reste juste a montrer que cette équation est vraie « au départ ». Nous ne pouvons
bien
évidemment pas partir des cas n = 0 et n = 1, puisque pour ces valeurs T(n) = 0. Nous partons
donc des cas n = 2 et n = 3 (la récurrence nécessite deux valeurs de départ) :
– Cas n = 2 : Fibonacci(2) = Fibonacci(1) + Fibonacci(0), et T(2) = 1. Pour que la propriété
d´désirée soit vraie, c doit donc vérifier :
1 ≥ 𝑐. 2 = 2𝑐 ⇔ 𝑐 ≤ 1/ 2

– Cas n = 3 : Fibonacci(3) = Fibonacci(2) + Fibonacci(1), et T(3) = 2. Pour que la propriété

d´désirée soit vraie, c doit donc vérifier :

2 ≥ 𝑐. 2 = 2√2𝑐 ⇔ 𝑐 ≤ √2/ 2

Donc si c = pour n ≥ 2, on a :𝑇(𝑛) ≥ 𝑐2 𝑛 2 𝑒𝑡 𝑑𝑜𝑛𝑐 𝑇(𝑛) = Ω(2 /

).

Exercice13 triangle de pascal

Algorithme triangle_pascal;
Var
P: tableau [1..100,1..100] de réels;
i,j,n: entiers ;
Debut
Ecrire(‘entrer l’ordre du triangle de pascal que vous voulez :’) ;
Lire(n) ;
(*remplissage du triangle de Pascal*)
 P[1,1] <-- 1 ;
Pour i <-- 2 à n+1 Faire
P[i,1] <-- 1 ;
Pour j<-- 2 à i-1 Faire
P[i,j] <-- P[i-1,j-1] + P[i-1,j]
Finpour j;
P[i,j] <-- 1 ;
Finpour i
(* affichagedu triangle de Pascal*)
Pour i <-- 1 à n+1 Faire
Pour j<-- 1 à i Faire
Ecrire(P[i,j] ,’ ‘);
Finpour j;
(*retour a la ligne *)
Finpour i
Fin.
 Série d'exercices numéro 4
graphes et arbres

Exercice1 :

En listes : 1 : (1,2,3,4); 2 : (2) 3 : (5,6)

4 : (4,3); 5 : (5,3) 6 : (6,5,3)
Bien sûr, il s’agit en fait de listes chaînées!
En matrice d’adjacence (zéros omis pour plus de clarté)

Exercice3 :

Pour construire la matrice d’incidence : tout d’abord on détermine sa taille et pour cela on
compte le nombre d’arêtes du graphe. Ensuite, pour chaque arête on remplit la matrice (qui
est au départ initialise a` 0). Cas des listes d’adjacence :
Entrée: tableau de liste d’adjacence E de taille $n$
Variables: entier i initialise a` 0
sommet x,y
Début:
Pour x de 1 a` n faire
Pour tout voisin de y de x faire
i++
fin du pour
fin du pour
B = matrice de taille n*i
i=0
Pour x de 1 a` n faire
Pour tout voisin de y de x faire
i++
B(x,i)=-1
B(y,x)=1
fin du pour
fin du pour
Fin.