algorithmique

1. Algorithmes et
structures de données
6ème cours
Patrick Reuter
maître de conférences
http://www.labri.fr/~preuter

2. Ingrédients d’algorithmes
• Affectation (ex. mois := 6, jours[1] := 31)
• Condition/Comparaison (ex. mois <= 12)
• Appel de fonction (ex. writeln(mois))
• Structure de contrôle
– Branchements conditionnels (multiples) (si ..
Alors .. Sinon)
– Boucles (tant que..faire, pour.. faire)
• Bloc d’instructions (begin .. end)

3. Motivation
Structure de données:
- tableau à 2 dimensions
…

4. Aujourd’hui
-Type enregistrement
- Complexité asymptotique

5. Déclaration de variables
var compteur : integer;
var diviseur : single;
var c : char;
var precision : double;
var nom : string;
var masculin : boolean;
var jours : array[1..12] of byte;
diviseur := 1.1; { Affectation }
compteur : = 1;
Nom := ‘Gerhard’;
Nombre entier
Nombre à virgule flottante
Nombre à virgule flottante avec double précision
Chaîne de caractères
Tableau

6. Déclaration de variables
var compteur : integer;
var diviseur : single;
var c : byte;
var precision : double;
var nom : string;
var masculin : boolean;
var jours : array[1..12] of byte;
diviseur := 1.1; { Affectation }
compteur : = 1;
Nom := ‘Gerhard’;
Nombre entier
Nombre à virgule flottante
Nombre à virgule flottante avec double précision
Chaîne de caractères
Tableau

7. Déclaration de variables
• Types de base prédéfinis
– Integer, boolean, single, …
• Type tableau
type t_tableau = array[1..12] of byte;
var jours : t_tableau;
- structure de données la plus connue
- structure homogène, chaque élément est du même type de
base
- occupe de la place successive dans la mémoire
- « random access » =l’accès aux différents éléments se fait à
coût égal

8. Enregistrements
• Motivation (à ne pas faire !)
type t_couleur = (rouge, vert, jaune);
var joueurnom : array[1..n] of string;
var joueurscore : array[1..n] of integer;
var joueurcouleur : array[1..n] of t_couleur;
joueurnom[1] := " Martin“;
joueurscore[1] := 0;
joueurcouleur[1] := rouge;
joueurnom[2] := " Romain“;
joueurscore[2] := 0;
joueurcouleur[2] := vert;
…

9. Déclaration de variables
• Type enregistrement (structure hétérogène)
type t_enregistrement = RECORD
nom_de_variable_1 : type1;
nom_de_variable_2 : type2;
...
nom_de_variable_n : typen;
END;
var dossier : t_enregistrement;
- structure hétérogène, les éléments peuvent être d’un type différent
- occupe de la place successive dans la mémoire
- « random access » = l’ accès aux différents éléments se fait à coût
égal

10. Type enregistrement (structure
hétérogène
• Déclaration du type
type t_enregistrement = RECORD
nom_de_variable_1 : type1;
nom_de_variable_2 : type2;
...
nom_de_variable_n : type2;
END;
var dossier : t_enregistrement;
• Affectation
dossier.nom_de_variable_1 := valeur;

11. Type enregistrement (structure
hétérogène)
Exemple
• Déclaration du type
type t_date = RECORD
an : integer;
mois : byte;
jour : byte;
END;
• Déclaration d’une variable
var aujourdhui : t_date;
• Affectation
aujourdhui.jour = 17;
aujourdhui.mois = 10;
aujourdhui.an = 2006;

12. Type enregistrement (structure
hétérogène)
Exemple
• Déclaration du type
type t_date = RECORD
an : integer;
mois : byte;
jour : byte;
END;
• Déclaration d’une variable
var aujourdhui : t_date;
• Affectation
with aujourdhui do
jour := 17;
mois := 10;
an := 2006;
end

13. type t_date = RECORD
an : integer;
mois : byte;
jour : byte;
END;
var aujourdhui : t_date;
aujourdhui.an #4000
...
#536.870.910
#536.870.911
...
aujourdhui.an; #4002
...
aujourdhui.an;#4001
214
7
0
17
#0
Occupe de la place
successive
dans la mémoire
aujourdhui.an; #4003
aujourdhui.mois; #4004
aujourdhui.jour; #4005
0
10

14. Type tableaux
d’enregistrements
• Déclaration du type enregistrement :
type t_chanson = RECORD
titre : string[100];
artiste : string[100];
album : string[100];
longueur : integer;
date : t_date;
END;
• Déclaration du type tableau
type t_tableau_chansons = array[1..n] of t_chanson;
• Déclaration d’une variable de ce type
var collection : t_tableau_chansons;
• Affectation
collection[1].title = ‘Riders on the storm’;
collection[1].artiste = ‘The Doors’;
...
collection[n].title = ‘Talkin Blues’;
...

15. Type tableaux
d’enregistrements
• Exercice
type t_chanson = RECORD
titre : string[100];
artiste : string[100];
album : string[100];
longueur : integer;
date : t_date;
END;
type t_tableau_chansons = array[1..n] of t_chanson;
var collection : t_tableau_chansons;
• Trouver l’artiste d’une chanson donnée ‘kaya’
i := 1;
tant que i<=n
i := i + 1;
fin tant que

16. Type tableaux
d’enregistrements
• Exercice
type t_chanson = RECORD
titre : string[100];
artiste : string[100];
album : string[100];
longueur : integer;
date : t_date;
END;
type t_tableau_chansons = array[1..n] of t_chanson;
var collection : t_tableau_chansons;
• Trouver l’artiste d’une chanson donnée ‘kaya’
i := 1;
tant que i<=n
si collection[i].title = ‘kaya’ alors
afficher collection[i].artiste;
i := i + 1;
fin tant que

17. Type tableaux
d’enregistrements
• Exercice
type t_chanson = RECORD
titre : string[100];
artiste : string[100];
album : string[100];
longueur : integer;
date : t_date;
END;
type t_tableau_chansons = array[1..n] of t_chanson;
var collection : t_tableau_chansons;
• Trouver l’artiste d’une chanson donnée ‘kaya’
trouve := FAUX;
i := 1;
tant que (i<=n AND trouve = FAUX)
si collection[i].title = ‘kaya’ alors
afficher collection[i].artiste;
trouve := VRAI;
i := i + 1;
fin tant que

18. Enregistrements
• Motivation (à ne pas faire !)
type t_couleur = (rouge, vert, jaune);
var joueurnom : array[1..n] of string;
var joueurscore : array[1..n] of integer;
var joueurcouleur : array[1..n] of t_couleur;
joueurnom[1] := " Martin“;
joueurscore[1] := 0;
joueurcouleur[1] := rouge;
joueurnom[2] := " Romain“;
joueurscore[2] := 0;
joueurcouleur[2] := vert;
…

19. Enregistrements
• Motivation (à ne pas faire !)
type t_couleur = (rouge, vert, jaune);
type t_joueur = RECORD
nom : string;
score : integer;
couleur : t_couleur;
END;
var joueur : array[1..n] of t_joueur;
joueur[1].nom := " Martin“;
joueur[1].score := 0;
joueur[1].couleur := rouge;
joueur[2].nom := " Romain“;
joueur[2].score := 0;
joueur[2].couleur := vert;

20. Exigences d’un programme
• Lisibilité
• Extensibilité
• Portabilité
• Réutilisable
• Fiabilité
• Efficacité (faible complexité)

21. Complexité
• Quel est le temps d’éxécution du programme?
 Complexité temporelle
De combien de mémoire le programme a-t-il besoin?
 Complexité de mémoire (ou Complexité spatiale)
Comment déterminer ces complexités ?
 méthode empirique
 méthode mathématique

22. Méthode empirique
• Avec une montre et un logiciel d’analyse de mémoire
• Problème : dépend des facteurs suivants
– de la machine utilisée;
– du jeu d’instructions utilisées
– de l’habileté du programmeur
– du jeu de données générées
– du compilateur choisi
– …
BIEN SUR : Le temps d’exécution dépend de la longueur de
l’entrée (par exemple le nombre de chansons dans la
collection).
Ce temps est une fonction T(n) où n est la longueur des
données d’entrée.

23. Méthode mathématique
• Théorie de la complexité
– Temporelle
– Spatiale
• Basée sur une machine abstraite
– Random-access memory (RAM)
– Instructions de base (affectation, boucle, appel de
fonctions …)
• longueur des données d’entrée n

24. 1er exemple pour T(n)
• Trouver l’artiste d’une chanson donnée
‘kaya’
i := 1;
tant que i<=n
si collection[i].title = ‘kaya’ alors
afficher collection[i].artiste;
i := i + 1;
fin tant que
• Affectations : 1 + n
• Comparaisons : 2n
• Appel de fonctions : n (Attention : considerer le “worst
case”, c-à-d la pire option)
•  T(n) = 4n+1

25. 2ème exemple pour T(n)
• Remplir une matrice identité
i := 1;
tant que i<=n faire
j := 1;
tant que j<=n faire
SI i=j ALORS
a[i][j] := 1;
SINON
a[i][j] := 0;
j := j + 1;
fin tant que
i := i + 1;
fin tant que

26. 2ème exemple pour T(n)
i := 1;
tant que i<=n faire
j := 1;
tant que j<=n faire
SI i=j ALORS
a[i][j] := 1;
SINON
a[i][j] := 0;
j := j + 1;
fin tant que
i := i + 1;
fin tant que
• Affectations : 1 + 2n + 2n2
• Comparaisons : n+ 2n2
•  T(n) = 4n2+3n+1

27. Théorie de la complexité –
Diminuer les constantes
• Comment peut-on
optimiser T(n) ?
• T(n) = 4n2+3n+1
• 1ère solution :
diminuer les
constantes a,b,c
• Exemple :
– T1(n) = 4n2+3n+1
– T2(n) = 4n2
– T3(n) = n2
n 1 2 3 10 20 100 1000
T1(n) 8 25 46 431 1661 40301 4003001
T2(n) 4 16 36 400 1600 40000 4000000
T3(n) 1 4 9 100 400 10000 1000000
T1/T2 2 1,56 1,28 1,08 1,04 1,01 1
T1/T3 8 6,25 5,11 4,31 4,15 4,04 4

28. Théorie de la complexité –
Diminuer les constantes
• 2 fonctions
– T1(n) = a1n2+b1n+c1
– T2(n) = a2n2+b2n+c2
• Amélioration :
– lim n ∞ T1(n) /T2(n) = a1/a2
• Pour des grands n, seule la constante du plus
grand degré est significative

29. Théorie de la complexité –
Changement de la fonction
2ème solution
changer la fonction
• T1(n) = log2n
logarithmique
• T2(n) = n
linéaire
• T3(n) = n log2 n
Quasi-linéaire
• T4(n) = n2
quadratique
• T5(n) = n3
cubique
• T6(n) = 2n
exponentiel

30. Théorie de la complexité –
Changement de la fonction
• Quel taille de n peut être résolue en 1 seconde, une minute, une heure ?
– Avec une machine de 1000 instructions par seconde
Ti(n) 1 sec 1 min 1 heure
log2n 21000 260000 23600000
N 1000 60000 36000000
n log2 n 140 4893 20000
n2
131 244 1897
n3
10 39 153
2n
9 15 21