1

Algorithmique et structures de données en C

É. Delozanne, L2-S4-prog4, Paris 5, 2004-05Elisabeth.Delozanne@math-info.univ-paris5.fr

Introduction-Le TDA Liste (1)

Cours 1

2

Intro et Le TDA LISTE (1)

Cours n°1 1. Introduction 2. Qualités d'un logiciel 2. Les types de données abstraits (TDA) 3. Le TDA LISTE 4. Opérations fondamentales sur les listes 5. Algorithmes abstraits sur les listesCours n° 2 6. Réalisations du TDA LISTE 7. Comparaison des réalisations

Programmes : \\diamant.ens.math-info.univ-paris5.fr\Data L2\prog4

Site : http://www.math-info.univ-paris5.fr/~delozanne/prog4Printemps05/AccueilProg4.htm

3

Objectifs de formation

adopter une attitude professionnelle apprendre à apprendre tout(e) seul(e) apprendre les principes qui supportent les techniques comprendre et anticiper les évolutions apprendre à mettre au point et à défendre un projet,

une conception méthodes d'enseignement qui nécessitent plus de

travail personnel

4

Objectifs d'apprentissage en prog4 langages de programmation

• maîtriser le langages C– gestion de la mémoire dynamique

• écrire des fonctions C lisibles et réutilisables structures de données de base et algorithmes

• connaître les principaux (et leur coût) • savoir choisir une structure de données et une mise en

oeuvre• s'habituer à utiliser des types de données abstraits• savoir passer d'une description abstraite à une réalisation

informatique en C programmation avancée

•  connaître les concepts de programmation : abstraction, encapsulation, généricité

5

Conclusion

adoptez une attitude positive et active des objectifs de formation ambitieux

• c'est bien pour vous• mais cela demande votre adhésion

Vous êtes les acteurs principaux de votre réussite

6

Programme du cours

Aspects programmation de l’étude des algorithmes et des structures de données• Concepts : abstraction, généricité, encapsulation

– Préparation à la POO• Techniques : la manipulation des pointeurs, la gestion de la

mémoire dynamique Structures de données

• Listes, Piles, Files, Arbres, Tables• (Graphes : dans le module d’algorithmique)• Tris

Choix : Présentation sous forme de Types de Données Abstraits• Écriture de programmes lisibles et efficaces (complexité)• Nous ne traiterons pas les problèmes d’optimisation de code

7

Qualités d'un logiciel valide :

• réalise exactement les tâches définies par la spécification robuste :

• fonctionne même dans des conditions anormales fiable :

• valide + robuste extensible :

• s'adapte aux changements de spécification réutilisable :

• en tout ou en partie dans de nouvelles applications, par d’autres compatible : peut être combiné avec d'autres autres :

• efficace, portable, vérifiable, facile d'utilisation

8

Maintenance

Partie immergée de l'iceberg Estimation

• adaptation à l'évolution des besoins (42 %)• modification des formats de données (17 %)• corrections d'erreurs urgentes (12 %)• corrections d'erreurs mineures (9 %)• modification de matériel (6 %)• documentation (5 %)• amélioration de l'efficacité (4 %)

9

Programmer aujourd'hui Bidouilleur génial isolé

• quelque fois utile• souvent considéré comme une calamité• en un mot : ringard

Membre d'une équipe• doit maintenir ou faire évoluer ou réutiliser du

code écrit par d'autres• doit s'adapter aux utilisateurs• doit choisir et utiliser sur des gros projets

– des bibliothèques de code déjà écrit– des ateliers de génie logiciel– des normes de qualité, guides de style, "design

patterns"

10

Principes des TDA

se placer à un niveau d'abstraction élevé• éviter les erreurs de conception

programmer avec des opérations de haut niveau • qui ne dépendent pas de la représentation interne• qui permettent de changer de représentation • qui permettent à l'utilisateur de se concentrer sur les

problèmes de conception en ignorant les détails de réalisation

encapsuler les données• n'accéder à la représentation interne que via des

fonctions • l'utilisateur ne voit que les services (l’interface) pas la

représentation interne

11

Les types de données abstraits (TDA) définition :

• un ensemble de données organisé pour que – les spécifications des objets et des

opérations sur ces objets – soient séparées – de la représentation interne des objets et

de la mise en œuvre des opérations

nés de préoccupation de génie logiciel• abstraction• encapsulation• vérification de types

12

Incarnation d'un TDA

définition :une incarnation (une réalisation, une mise en œuvre, une « implémentation ») d'un TDA est • la déclaration de la structure de données particulière

retenue pour représenter le TDA– L’interface (fichier .h)

• et la définition (i.e le code) des opérations primitives dans un langage particulier

– La réalisation (fichier .c) on parle aussi de type concret de données

13

En résumé

Interface Réalisation

Spécification Code C

Utilisateurs

(autres programmeurs)

Programmeur

Fichier en-tête (.h) Fichier source (.c)

14

Avantages des TDA

écriture de programmes en couches : • la couche supérieure traite le problème dans les termes du

domaine de problèmes– Empiler (x, P)

• la couche inférieure entre dans les détails du langage de programmation

– tab[sp++] = x séparation claire

• des offres de service • du codage

facilité de compréhension et d'utilisation des modules de codes prise en compte de types complexes briques d'une structuration modulaire rigoureuse introduction à la programmation objet

15

Inconvénients des TDA

l'utilisateur d'un TDA connaît les services mais ne connaît pas leur coût

le concepteur du TDA connaît le coût des services mais ne connaît pas leurs conditions d'utilisation

le choix des primitives est quelque fois difficile à faire

16

Orientation de prog4 Règle empirique des 90-10 (80-20)

• Un programme passe 90 % de son temps sur 10 % du code.

Sur ces 10 % l'efficacité est cruciale : • chercher à optimiser le code• s'intéresser à la représentation interne

Pour le reste du programme • les autres critères sont primordiaux :

– lisibilité, maintenabilité etc. • rester à un niveau d'abstraction élevé.

17

Règles de lisibilité à respecter

1. Commencez par décrire en français l’organisation générale de votre programme

2. Écrivez des fonctions courtes (entre 1 et 20 lignes)

3. Commentez les prototypes des fonctions (paramètres, valeur de retour, rôle de la fonction, astuces éventuelles)

4. Utilisez les fichiers d’en-têtes

5. Soyez cohérents dans les identificateurs que vous définissez

6. Respectez les règles de base de la programmation structurée• n’utilisez pas de variables globales, ni de goto, ni

de break, ni d’exit, ni de return dans une boucle• (sauf exception à justifier impérativement)

18

Intro et Le TDA LISTE (1)

Cours n°1 1. Introduction 2. Qualités d'un logiciel 2. Les types de données abstraits (TDA) 3. Le TDA LISTE 4. Opérations fondamentales sur les listes 5. Algorithmes abstraits sur les listes

Cours n° 2 6. Réalisations du TDA LISTE 7. Comparaison des réalisations

19

Le TDA LISTE

Définition• une liste est une suite finie (éventuellement vide)

d'éléments liste homogène :

• tous les éléments sont du même type liste hétérogène :

• les éléments sont de type différents dans la suite nous intéressons aux listes homogènes

20

TDA ELEMENTtous les éléments appartiennent à un TDA ELEMENT qui

possède un élément vide et sur lequel on peut : saisir un élément

• ElementLire afficher un élément

• ElementAfficher affecter dans un élément un autre élément

• ElementAffecter tester si deux éléments sont identiques

• ElementIdentique allouer la mémoire dynamique ou initialiser un élément

• ElementCreer libérer la mémoire allouée pour un élément

• ElementDetruire

21

TDA POSITION

On dispose d'un TDA POSITION permettant de repérer un élément dans la liste sur lequel on peut :

tester si deux positions sont égales :• PositionIdentique

affecter dans une position une autre position• PositionAffecter

Dans la suite : • une position sera un entier ou un pointeur

Pour alléger les notations• Nous testerons l’égalité de deux positions avec ==• Nous utiliserons l’affectation = pour affecter une

position dans une autre

22

SIGNATURE DU TDA LISTEÉlément particulier : liste vide

Utilise : ELEMENT, POSITION

Fonctions primitives : test

• ListeVide consultation de la liste

• ListeAccèder parcours

• ListePremier, ListeSuivant, ListeSentinelle modification de la liste

• ListeInsérer, ListeSupprimer allocation, libération de mémoire dynamique

• ListeCreer, ListeDetruire

23

Opérations classiques sur les listes à l'aide de ces quelques primitives, on peut exprimer

les opérations classiques sur les listes,et ce, • sans se soucier de la réalisation concrète des listes• sans manipuler ni pointeurs, ni tableaux, ni faux

curseur• sans mettre les mains dans le cambouis

trois exemples :• ListeAfficher, ListePrecedent• ListeLocaliser

d'autres exemples en TD et en TP• raz, nettoyer• longueur, insérer au début, à la fin

supprimer au début, supprimer à la fin ...

24

ListeAfficher Signature :

• un argument la liste l à afficher ; pas de valeur de retour• affiche chaque élément de la liste

void ListeAfficher(LISTE L) {POSITION p, fin = ListeSentinelle(L);

printf("\n(");

for (p = ListePremier(L); p!= fin ; p = ListeSuivant(p, L)) {ElementAfficher(ListeAcceder(p, L));

} printf(")\n");}

25

ListePrecedent signature:

• deux arguments : une position p et une liste l• retourne la position précédent p dans l si elle existe, sinon

retourne la sentinelle

POSITION ListePrecedent (POSITION p, LISTE L) {

POSITION avant, courant, fin ;

avant = ListePremier (L) ;

courant = ListeSuivant (avant, L) ;

fin = ListeSentinelle(L) ;

for(;p !=courant && courant !=fin;

avant=courant, courant=ListeSuivant(courant,L));

return (courant == p ? avant : fin);

}

26

ListeLocaliser signature

• deux arguments : un élément x et une liste l• retourne la première position où on rencontre x dans l

et sinon retourne la sentinelle

POSITION ListeLocaliser (ELEMENT x, LISTE L) {

POSITION p = ListePremier (L) , fin = ListeSentinelle(L) ;

for (; p != fin && !ElementIdentique(x, ListeAcceder(p, L)) ;p = ListeSuivant (p,L) );return p ;

}

27

Parcours d’une liste Même structure d’algorithme que parcours de tableaux Parcours du début à la fin

• Initialisations : (dont) position courante = debut• Continuation : position courante != position finale• Post- instruction : passer à la position suivante• For (initialisation; continuation; post-instruction) {

Traitement sur la position courante}

Parcours de recherche• Initialisations : (dont) position courante = debut• Continuation : (pas au bout ) ET (pas trouvé)• Post- instruction : passer à la position suivante• For (initialisation; continuation; post-instruction) {

Traitement sur la position courante}

28

Algorithmes abstraits sur le TDA LISTE algorithmes utilisant les opérations sur les listes

ex :

ListePurger qui élimine les répétitions dans une liste signature : trois signatures sont possibles ListePurger

1. modifie physiquement la liste initiale (qui est donc perdue) et qui est un argument passé par adresse (purge sur place)

2. retourne dans un argument passé par adresse une copie de la liste initiale, copie où les répétitions ont été enlevées

3. retourne une copie de la liste initiale crée à l’intérieur de la fonction, copie où les répétitions ont été enlevées (à côté de la liste à purger)

Programmation impérative : version 1 et 2 Programmation fonctionnelle : version 3

29

Programmation impérative Le résultat est

• un paramètre de la procédure modifié physiquement à l'exécution• en C :

–paramètre obligatoirement passé par adresse

version 1 : purge sur place• ListePurger(L) modifie physiquement la liste L en supprimant

les répétitions version 2 : purge à côté

• ListePurger(L, LL) modifie physiquement L – Au départ L est vide – Après L contient une version purgée de LL (qui elle est

inchangée)

30

Construction à côté du résultat, prog impérativevoid ListePurger (LISTE L, LISTE LL ) {

ELEMENT x ;POSITION p, q, fin ;

fin = ListeSentinelle (LL) ;p = ListePremier (LL); q = ListePremier (L);for ( ; p != fin ; p = ListeSuivant(p, LL) ){ ElementAffecter(&x, ListeAcceder(p, LL));

if (ListeLocaliser(x,L) == ListeSentinelle(L)) {ListeInserer (x, q, L) ;q = ListeSuivant(q, L);}

}

}

31

Construction à côté, prg fonctionnelleLISTE ListePurger (LISTE L) {

LISTE LL ;ELEMENT x ;POSITION p, q, fin ;LL = ListeCreer() ; /* alloue la mémoire pour la liste vide */

fin = ListeSentinelle (L) ;p = ListePremier (L); q = ListePremier (L);for ( ; p != fin ; p = ListeSuivant(p, L) ){ x = ListeAcceder(p, L) ;

if (ListeLocaliser(x, LL) == ListeSentinelle(LL)) {ListeInserer (x, q, LL) ;q = ListeSuivant(q, LL);}

}return LL ;/* attention retour d'un pointeur déclaré dans la fonction

La zone pointée a-t-elle été allouée dynamiquement (sinon pointeur fou) ? Si oui, Qui la libérera? (fuites de mémoires possibles*/

}

32

Programmation fonctionnelle Le résultat est retourné par la fonction au

programme qui l'a appelée Ce type de programmation extrêmement puissant

est mal supporté par le langage C• aucun problème pour les résultats de type

simple retourné par valeur• deux problèmes pour les résultats locaux

retournés par adresse :– le choléra : pointeur fou– la peste : fuite de mémoire

• Cf. prog3 et TD1 et TD-Machine 1 de prog3

33

Utilisation des TDA en C Difficultés liées au langage C

• liées aux problèmes du passage des paramètres par valeur• liées à l'absence de gc (glaneur de cellules,

garbage collector, ramasse-miettes) Difficultés liées au TDA

• l’efficacité des opérations dépend de la réalisation des opérations primitives

34

Take Home Message lors de la conception d’un programme

• penser abstrait ;

lors de la mise au point • se soucier

– des représentations, – du langage – de l'efficacité ; – et en C de la gestion de mémoire

35

Auto-évaluation1. Quelles sont les différentes qualités d’un logiciel ?

2. Quelles sont les règles de lisibilité des programmes à respecter en prog4 ?

3. Qu’est-ce que la règle des 90-10 ?

4. Qu’est-ce qu’on appelle l’interface d’un TDA ? l’interface utilisateur d’une application ? Qui est l’utilisateur d’un TDA ? D’une application ?

5. Quelles sont les primitives du TDA ELEMENT ? Du TDA LISTE ?

6. Écrire en fonction des primitives du TDA LISTE et du TDA ELEMENT, les opérations ListeAfficher, ListeLocaliser, ListePrecedent

7. Qu’est-ce qu’un pointeur fou ? Une fuite de mémoire ? Pourquoi sont-ce des problèmes ? Comment les éviter ?

8. Pourquoi le C supporte-t’il difficilement le style de programmation fonctionnelle quand le résultat retourné par la fonction est une adresse ?

36

Intro et Le TDA LISTE (1)

Cours n°1 1. Introduction 2. Qualités d'un logiciel 2. Les types de données abstraits (TDA) 3. Le TDA LISTE 4. Opérations fondamentales sur les listes 5. Algorithmes abstraits sur les listes

Cours n° 2 6. Réalisations du TDA LISTE 7. Comparaison des réalisations