ETNA – 1ème année Guillaume Belmas –

Présentation au sujet: "ETNA – 1ème année Guillaume Belmas –"— Transcription de la présentation:

1 ETNA – 1ème année Guillaume Belmas – guillaume@3ie.org
Algorithmique ETNA – 1ème année Guillaume Belmas –

2 Plan de cours Cours 1: Listes chaînées, piles et files
Cours 2: Arbres, tables de hash Cours 3: Graphes Cours 3 bis: Coding guidelines Cours 4: Modélisation objet: rappels Cours 5: Design patterns 1 Cours 6: Design patterns 2

3 Listes chaînées, piles et files

4 Rappels Analyse d’algorithme Analyse pessimiste des performances
Le pire cas d’une recherche arrive souvent ! Le cas optimal ne nous apprend rien Le cas moyen est difficile à obtenir Le pire cas garantit que l’algorithme ne fera jamais moins bien

5 Rappels Complexité d’un algorithme
Somme des coûts des actions élémentaires S’exprime en fonction du volume de données à traiter Complexité != Temps d’exécution

6 Rappels O(1) = Exécution en temps constant (le mieux !)
O(n) = Parcours d’une liste de n éléments O(n2) = Parcours d’une matrice Plus la complexité est élevée, moins l’algorithme est efficace pour un grand nombre de données

7 Rappels Les structures (agrégats)
Éléments de différents types comme type unique Utile pour représenter les données métier typedef struct s_personne { char *Nom, int Age, char Sexe } t_personne;

8 Les listes chaînées

9 Les listes chaînées Définition
Ensemble d’éléments de même type liés par des pointeurs 1 élément = 2 parties (agrégat) Le champ de données Le pointeur suivant Données Élément suivant

10 Les listes chaînées Définition récursive Une liste est:
Soit une liste vide (représentée par le NULL) Soit un élément suivit d’une liste Données Élément suivant Tête de liste

11 Les opérations de base Déclaration de la structure d’un élément
struct s_list { struct s_list *suivant; void *donnee; }; typedef struct s_list t_list; Nouvelle liste t_list *liste = (t_list)malloc(sizeof(t_list)); liste->suivant = null; liste->donnee = …

12 Les opérations de base Insertion d’un élément
Prototype: int list_ins_next(t_list **list, t_list *element, void *donnee) list : la liste de destination element: élément qui précédera le nouvel élément donnee: données du nouvel élément Complexité d’exécution O(1) pour un ajout en tête de liste Éventuellement O(n) pour un ajout avec recherche

13 Les opérations de base

14 Les opérations de base int list_ins_next(t_list **liste, t_list *element, const void *donnee) { t_list *nouv_element; if ((nouv_element = (t_list *)malloc(sizeof(t_list))) == NULL) return -1; nouv_element->donnee = (void *)donnee; if (element == NULL) // Insertion en tête de liste nouv_element->suivant = *liste; *liste = nouv_element; }

15 Les opérations de base else {
nouv_element->suivant = element->suivant; element->suivant = nouv_element; } return 0;

16 Les opérations de base Suppression d’un élément
Prototype: int list_rem_next(t_list **list, t_list *element, void **donnee) list : la liste de destination element: élément qui précédera le nouvel élément donnee: données du nouvel élément Complexité d’exécution O(1) pour un ajout en tête de liste Éventuellement O(n) pour un ajout avec recherche

17 Les opérations de base

18 Les opérations de base int list_rem_next(t_list **liste, t_list *element, void **donnee) { t_list *ancien_element; if (list_size(*liste) == 0) return -1; if (element == NULL) //Gestion de la suppression en tête de liste *donnee = *liste->donnee; ancien_element = *liste; *liste = *liste->suivant; }

19 Les opérations de base else { if (element->suivant == NULL)
return -1; *donnee = element->suivant->donnee; ancien_element = element->suivant; element->suivant = element->suivant->suivant; } free(ancien_element); return 0;

20 Quizz A vous de jouer !  Donnez les 2 implémentations de list_size
- Itérative - Récursive int list_size(t_list *liste)

21 Solutions Implémentation itérative int list_size(t_list *liste) {
int count = 0; t_list *curseur = liste; if (curseur == NULL) return count; while (curseur->suivant != NULL) count++; curseur = curseur->suivant; }

22 Solutions Implémentation récursive int list_size(t_list *liste) {
if (liste == NULL) return 0; else return (1 + list_size(liste->suivant)); }

23 Avantages Allocation dynamique de la mémoire à l’éxecution
Pas besoin de connaître le volume de données lors du design de l’application Faible coût de l’insertion et de la suppression Complexité O(1) des opération d’ajout et de suppression

24 Inconvénients Gestion des données relativement lourde
Déréférencement des pointeurs Nécessité d’avoir un pointeur par donnée Mal adapté aux parcours Pas d’accès direct aux données Parcours lent du au déréférencement

25 Listes chaînées VS tableaux

26 Les autres types de liste
Listes doublement chaînées Pointeur suivant et precedent Traitement +/- lourd mais la complexité ne change pas Listes circulaires Le dernier élément pointe sur le premier Listes custom Primitives optimisées en fonction des besoins

27 Les piles (stacks) Stockage et restitution de l’information selon l’ordre LIFO (Last In First Out). Gestion simple avec peu de primitive « Empiler » une donnée (push) « Dépiler » une donnée (pop) Et les primitives de création et destruction

28 Fonctionnement

29 Implémentation Pas besoin d’accès direct aux données
Structure sollicitant l’ajout et la suppression de données Les listes sont donc adaptées pour servir de support aux piles !

30 Implémentation Push (empiler) == Ajouter en début de liste
Pop (dépiler) == suppression du 1° élément

31 Les files (queue) Stockage et restitution de l’information selon l’ordre FIFO (First In First Out). Tout comme les piles, peu de primitives: « Enfiler » (équivalent du push) « Défiler » (équivalent du pop)

32 Fonctionnement

33 Implémentation Structure très similaire aux piles
Plusieurs possibilités d’implémentation Utilisation de tableaux (limite la taille de la file) Utilisation des listes chaînées Liste à 2 pointeurs (Tête et Queue)

34 Implémentation Enfiler() == Ajouter en FIN de liste
Défiler() == Suppression du 1° élément Exemple d’utilisation Gestion des évènements dans un OS

35 Conclusion « L’emploi de ces structures dépend
essentiellement du besoin de l’application. »

36 Questions