1 Algorithmique et structures de données en C É. Delozanne, L2-S4-prog4, Paris 5, 2004-05 [email protected] Introduction-Le TDA Liste (1) Cours 1
Apr 04, 2015
1
Algorithmique et structures de données en C
É. Delozanne, L2-S4-prog4, Paris 5, [email protected]
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