République Algérienne Démocratique et Populaire

Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Université Abderrahmane MIRA de Bejaia
Faculté des Sciences Exactes

Programmation
avancéé
KHOUFACHE née Bachiri Lina, bachiri.lina@gmail.com

Département d’informatique
Master 1

Année universitaire 2019-2020

 CHAPITRE 1
Introduction à la programmation avancée

1.1 Définition d’un Algorithme

Un algorithme est une suite finie d’opérations élémentaires constituant un schéma de

calcul ou de résolution d’un problème.

1.2 Double problématique d’un algorithme

1. Trouver une méthode de résolution (exacte ou approchée) du problème.

2. Trouver une méthode efficace: savoir résoudre un problème est une chose, le résoudre
efficacement en est une autre.

1.3 Calculer
1.3.1 Méthode naïve

Fonction puissance-naïve (x réel, n entier) : réel

Var i entire; y: réel;

Debut

Si ( n=0 ) alors

retourner(1) ;

Sinon

y x;

Pour i allant de 2 à n faire

y x;

retourner(y) ;

Fin si ;

Fin.

Pour calculer avec la fonction puissance-naïve on a besoin de n-1 multiplications

Exemple pour calculer x15 on a besoin de 14 multiplications

1
1.3.2 Amélioration de la fonction naïve

1. Méthode binaire

Algorithme pour le calcul de

1. Écrire n sous forme binaire

2. Remplacer chaque :

– « 1 » par la paire de lettres « SX » ;

– « 0 » par la lettre « S ».

3. Éliminer la paire « SX » la plus à gauche.

4. Résultat : un mode de calcul de où

– S désigne « élever au carré »;

– X désigne « multiplier par x ».

Le tout en commençant par x

Illustration avec n=15

1. Convertir 15 en binaire 15= 1111

2. 1 1 1 1
sx sx sx sx

3. Eliminer sx le plus à gauche

1 1 1 1
sx sx sx

4. Nous partons de x et nous obtenons successivement : x2, x3, x6, x7, x14, x15

Nous sommes donc capables de calculer x15 en 6 multiplications au lieu de 14. Le nombre de
multiplications dans cette méthode est ⌊ ⌋ avec b(n) est le
nombre de « 1 » dans l’écriture binaire de n.

Pour n=15

⌊ ⌋

Illustration avec n=23

1. Convertir 23 en binaire 23= 10111

2
 2. 1 0 1 1 1
sx s sx sx sx

3. Eliminer sx le plus à gauche

1 0 1 1 1
s sx sx sx

4. Nous partons de x et nous obtenons successivement : x2, x4, x5, x10, x11, x22, x23

Pour n=23

⌊ ⌋

2. Méthode des facteurs

Cette méthode consiste à utiliser une factorisation de n : n = p*q où p est le plus petit
diviseur premier de n et q > 1. On calcule d’abord qu’on élève ensuite à la puissance q.

Illustration avec

On a on calcule en deux multiplications, puis on élève à la

puissance 5 ( ) en trois multiplications, y5 = y * (y2) 2
Donc, par la méthode de
factorisation, on calcule avec 5 multiplications.

3
 CHAPITRE 2
Complexité et optimalité

2.1 Introduction

La complexité était développée dans le but de comparer efficacement différents

algorithmes entre eux, afin de savoir lequel était le meilleur pour un problème donné.

La complexité des algorithmes est l’évaluation du coût d’exécution d’un algorithme en

termes de temps (complexité temporelle) ou d’espace mémoire (complexité spatiale). Dans ce
qui suit on va s’intéresser à la complexité en temps d’exécution.

2.2 Modèle de machine

Le temps d’exécution d’un algorithme dépend de la machine sur laquelle s’exécute

l’algorithme, de la traduction de l’algorithme en langage exécutable par la machine. Mais
nous ferons ici abstraction de ces deux facteurs, pour se concentrer sur le coût des actions
résultant de l’exécution de l’algorithme, en fonction d’une “taille” n des données traitées. Ceci
permet en particulier de comparer deux algorithmes traitant le même calcul.

Pour que le résultat de l’analyse de la complexité d’un algorithme soit pertinent, il faut
avoir un modèle de machine sur laquelle l’algorithme sera implémenté (sous forme de
programme). On prendra comme référence un modèle de machine à accès aléatoire (RAM)
et à processeur unique, où les instructions sont exécutées l’une après l’autre, sans opérations
simultanées.

2.3 Définition Complexité (temporelle) des algorithmes

La complexité d'un algorithme est le nombre d'opérations élémentaires (affectations,

comparaisons, opérations arithmétiques …) effectuées par un algorithme.

Formellement, l’expression d’une complexité prend la forme d’une fonction

mathématique en fonction de la taille n des données.

Exemples :
- Si le tri du tableau a une complexité 𝑓(n) = + , on dira que le tri possède une complexité
linéaire.

4
- Si un autre algorithme de tri possède une complexité 𝑓(n) = 2, alors on considèrera que ce
tri a une complexité quadratique.

2.4 Objectifs de calcul de la complexité

1. Pouvoir prévoir le temps d'exécution d'un algorithme
2. Pouvoir comparer deux algorithmes réalisant le même traitement

2.5 Cas de complexité

1. Complexité au pire : temps d'exécution maximum, dans le cas le plus défavorable.
2. Complexité au meilleur : temps d'exécution minimum, dans le cas le plus favorable
(en pratique, cette complexité n'est pas très utile).
3. Complexité moyenne : temps d'exécution dans un cas médian, ou moyenne des temps
d'exécution.

Le plus souvent, on utilise la complexité au pire, car on veut borner le temps d'exécution.

2.6 Approximations de la complexité

Les complexités algorithmiques théoriques sont toujours des approximations :

1. Première approximation : on ne calcule que la forme générale de la complexité

2. Deuxième approximation : on ne considère souvent que la complexité au pire
3. Troisième approximation : on ne regarde que le comportement asymptotique de la
complexité car le temps de calcul ne pose pas de problème lorsqu’on traite des
données peu volumineuses.

2.7 Notations de Landau

Lors de l’évaluation de la complexité d’un algorithme, on s’intéresse généralement à son

ordre de grandeur et on utilise les notations de landau suivantes:
O : f = O(g) <=> Ǝ n0 >0, Ǝ c , f (n) c* g(n). (g est une borne supérieure
asymptotique de f).
: f = (g) <=> g = O(f). (g est une borne inferieure asymptotique de f).
: f = (g) <=> f = O(g) et g = O( f ) (g est une borne approchée asymptotique de f).

Exemple soient 𝑓
Nous avons 𝑓
En effet 𝑓

5
 2.8 Ordre de grandeur
Pour comparer des algorithmes, il n’est pas nécessaire d’utiliser la fonction de
complexité T, mais seulement l’ordre de grandeur asymptotique, noté O (« grand O »). Une
fonction T(n) est en O(f(n)) (« en grand O de f(n) » ) si :
Ǝ ,Ǝc , T(n) c* f(n).
Autrement dit :
T(n) est en O(f(n)) s’il existe un seuil n0 à partir duquel la fonction T est toujours dominée
par la fonction f, à une constante multiplicative fixée c près.

Caractérise le comportement asymptotique

(𝑓 ) Si Ǝ n0 >0, Ǝ c , T (n) c*f (n).

Exemples :





2.9 Efficacité d’un algorithme

On considère généralement qu’un algorithme est plus efficace qu’un autre si son temps
d’exécution dans le cas le plus défavorable a un ordre de grandeur inférieur.

2.10 Classes de la complexité

Un algorithme A est dit de complexité :

6
  constante si complexité(A) = O(1)
 logarithmique si complexité(A)=O(log(n))
 linéaire si complexité(A) = O(n)
 quadratique si complexité(A) = O( )
 polynomiale si complexité(A) = O( ) pour k 3
 exponentielle si complexité(A) =O(en)

2.11 Exemple Tri par insertion

Nous notons
ci: le coût en temps d'exécution d'une instruction i
t j: nombre d’exécutions de la boucle tant que pour la valeur j

Algorithme tri-insertion Coût Nombre

Var n, i, j, x : entier; d’itérations
A:tableau;
Debut
Pour j allant de 2 à n faire c1 n
debut pour
x A[j]; c2 n-1
i c3 n-1
tant que i > 0 et A[i] > x faire c4 ∑

debut tant que

∑
A[i+1] A[i]; c5
c6 ∑
i i-1;
fintant que

n-1
A[i+1] x; c7
Finpour
Fin

7
Complexité

T(n) = c1* n +c2 *(n-1)+ c3 *(n-1) +c4 ∑ + ∑ + ∑ +

c7 *

1. Complexité au meilleur cas (tableau trie)

tj=1

T(n) = c1* n +c2 *(n-1)+ c3 *(n-1) +c4 *1+ c7 *

= (c1+c2+c3+c7)*n- (c2+c3+c4+c7)

2. Complexité au pire cas (tableau trié dans l’ordre inverse)

tj=j donc ∑ et ∑

T(n)= c1* n +c2 *(n-1)+ c3 *(n-1) +c4

+ + + c7 *

T(n)= ( +( )n-

(c2+c3+c4+c7)

3. complexité au moyen cas

tj=j/2
t(n)= O( ) (quadratique)