Vous êtes sur la page 1sur 30

Algorithmes et

structures de données

6ème cours
Patrick Reuter
maître de conférences

http://www.labri.fr/~preuter
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)
Motivation

Structure de données:

- tableau à 2 dimensions

Aujourd’hui

-Type enregistrement
- Complexité asymptotique
Déclaration de variables
var compteur : integer; Nombre entier

var diviseur : single;


Nombre à virgule flottante
var c : char;

var precision : double;


Nombre à virgule flottante avec double précision
var nom : string;

var masculin : boolean; Chaîne de caractères

var jours : array[1..12] of byte; Tableau

diviseur := 1.1; { Affectation }


compteur : = 1;
Nom := ‘Gerhard’;
Déclaration de variables
var compteur : integer; Nombre entier

var diviseur : single;


Nombre à virgule flottante
var c : byte;

var precision : double;


Nombre à virgule flottante avec double précision
var nom : string;

var masculin : boolean; Chaîne de caractères

var jours : array[1..12] of byte; Tableau

diviseur := 1.1; { Affectation }


compteur : = 1;
Nom := ‘Gerhard’;
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
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;


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
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;
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;
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
type t_date = RECORD
an : integer;
mois : byte;
jour : byte;
END;
var aujourdhui : t_date;

#536.870.911
#536.870.910 ...

...
aujourdhui.jour; #4005 17
aujourdhui.mois; #4004 10
aujourdhui.an; #4003 0
aujourdhui.an; #4002 0 Occupe de la place
aujourdhui.an;#4001 7 successive
aujourdhui.an #4000 214 dans la mémoire
...
#0
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’;
...
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
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
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
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;


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;


Exigences d’un programme
• Lisibilité
• Extensibilité
• Portabilité
• Réutilisable
• Fiabilité

• Efficacité (faible complexité)


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
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.
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


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
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
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
Théorie de la complexité –
Diminuer les constantes
n 1 2 3 10 20 100 1000

• Comment peut-on
optimiser T(n) ? T1(n) 8 25 46 431 1661 40301 4003001

• T(n) = 4n2+3n+1
• 1ère solution : T2(n) 4 16 36 400 1600 40000 4000000

diminuer les
constantes a,b,c T3(n) 1 4 9 100 400 10000 1000000

• Exemple :
– T1(n) = 4n2+3n+1 T1/T2 2 1,56 1,28 1,08 1,04 1,01 1
– T2(n) = 4n2
– T3(n) = n2
T1/T3 8 6,25 5,11 4,31 4,15 4,04 4
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
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
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

Vous aimerez peut-être aussi