Structures de données et algorithmes – C5 Maria-Iuliana Dascalu, PhD

Présentation au sujet: "Structures de données et algorithmes – C5 Maria-Iuliana Dascalu, PhD"— Transcription de la présentation:

1 Structures de données et algorithmes – C5 Maria-Iuliana Dascalu, PhD mariaiuliana.dascalu@gmail.com

2 Objectifs Listes linéaires chainées – concepts et types de listes Operations de base pour mettre en œuvre des listes Piles et files d'attente mises en œuvre avec listes chainées Autres applications avec listes chainées

3 Généralités Une liste est une instance d'un ADT qui officialise le concept de collection ordonnée d'entités. Le contenu de chaque élément de la liste: – informations utiles – pointeur(s) vers l'élément voisin de la liste

4 Operations de base pour mettre en œuvre des listes ajouter - ajouter un élément (entité) à la liste: – au début – à la fin – à une position arbitraire supprimer - supprimer un élément (entité) à partir du début / fin de la liste ou prise en compte de l'indice / le contenu obtenir un élément, prise en compte l'indice mettre à jour un élément – mettre à jour de l'information / contenu d'un élément obtenir la longueur de la liste – le nombre d'éléments dans la liste ….

5 Mises en œuvre avec…(1) des listes linéaires liées individuellement, des listes linéaires doublement chaînées, des listes circulaires: – chaque noeud contient des informations et le lien vers ses voisins (listes doublement chaînées) ou seulement vers l'élément suivant de la liste (listes liées individuellement) ou le dernier élément est lié au premier élément (listes circulaires) – les nœuds sont allouées dynamiquement, car ils sont nécessaires, donc, pratiquement, nous pouvons obtenir des listes d'une taille limitée que par la mémoire de programme

6 Mises en œuvre avec…(2) tableaux dynamiques: – listes sont stockées dans des vecteurs – si, lors de l'ajout d'un nouvel élément, la taille du tableau est dépassée, le tableau est réaffecté (reallocated) – cette mise en œuvre a l'avantage d'une vitesse accrue daccès: les éléments sont dans des emplacements de mémoire successifs, mais… – elle est limitée par la quantité de mémoire contiguë à la disposition du programme

7 Types de listes (1) listes linéaires liées individuellement (singly- linked linear lists) listes linéaires doublement chaînées (doubly- linked linear lists)

8 Types de listes (2) listes circulaires liées individuellement (singly-linked circular lists) listes circulaires doublement chaînées (doubly-linked circular lists)

9 Listes linéaire doublement chaînée– Implementation (mylist.h) #include using namespace std; template struct list_elem { T info; struct list_elem *next, *prev; }; template class LinkedList { public: struct list_elem *pfirst, *plast;

10 Listes linéaire doublement chaînée– Implementation (mylist.h) void addFirst(T x) { struct list_elem *paux; paux = new struct list_elem ; paux->info = x; paux->prev = NULL; paux->next = pfirst; if (pfirst != NULL) pfirst->prev = paux; pfirst = paux; if (plast==NULL) plast=pfirst; } void addLast(T x) { struct list_elem *paux; paux = new struct list_elem ; paux->info = x; paux->prev = plast; paux->next = NULL; if (plast != NULL) plast->next = paux; plast = paux; if (pfirst == NULL) pfirst = plast; } void removeFirst() { struct list_elem * paux; if (pfirst != NULL) { paux = pfirst->next; if (pfirst == plast) plast = NULL; delete pfirst; pfirst = paux; if (pfirst != NULL) pfirst->prev = NULL; } else cout<<"The list is empty"<<endl; } void removeLast() { struct list_elem *paux; if (plast != NULL) { paux = plast->prev; if (pfirst == plast) pfirst = NULL; delete plast; plast = paux; if (plast != NULL) plast->next = NULL; } else cout<<"The list is empty"<<endl; }

11 mylist.h struct list_elem * findFirstOccurrence(T x) { struct list_elem *paux; paux = pfirst; while (paux != NULL) { if (paux->info == x) return paux; paux = paux->next; } return NULL; } struct list_elem * findLastOccurrence(T x) { struct list_elem *paux; paux = plast; while (paux != NULL) { if (paux->info == x) return paux; paux = paux->prev; } return NULL; } void removeFirstOccurrence(T x) { struct list_elem *px; px = findFirstOccurrence(x); if (px != NULL) { if (px->prev != NULL) px->prev->next = px->next; if (px->next != NULL) px->next->prev = px->prev; if (px->prev == NULL) // px == pfirst pfirst = px->next; if (px->next == NULL) // px == plast plast = px->prev; delete px; } void removeLastOccurrence(T x) { struct list_elem *px; px = findLastOccurrence(x); if (px != NULL) { if (px->prev != NULL) px->prev->next = px->next; if (px->next != NULL) px->next->prev = px->prev; if (px->prev == NULL) // px == pfirst pfirst = px->next; if (px->next == NULL) // px == plast plast = px->prev; delete px; }

12 mylist.h int isEmpty() { return (pfirst == NULL); } LinkedList() { pfirst = plast = NULL; } void printList() { struct list_elem *p; p = pfirst; while (p != NULL) { printf("%d\n", p->info); p = p->next; } };

13 list.cpp #include "mylist.h" int main() { LinkedList l; l.addFirst(89); l.addFirst(34); l.addLast(79); l.addLast(34); l.addFirst(89); l.printList(); l.removeLastOccurrence(89); l.printList(); l.removeLast(); l.removeFirst(); l.printList(); return 0; }

14 Pille avec listes linéaire chaînée template class Stack { private: LinkedList ll; public: void push(T x) { ll.addLast(x); } T pop() { if (isEmpty()) { fprintf(stderr, "Error 102 - The stack is empty!\n"); T x; return x; } T x = ll.plast->info; ll.removeLast(); return x; } T peek() { if (isEmpty()) { fprintf(stderr, "Error 103 - The stack is empty!\n"); T x; return x; } return ll.plast->info; } int isEmpty() { return (ll.isEmpty()); } };

15 File d'attente avec listes linéaire chaînée template class Queue { private: LinkedList ll; public: void enqueue(T x) { ll.addLast(x); } T dequeue() { if (isEmpty()) { fprintf(stderr, "Error 102 - The queue is empty!\n"); T x; return x; } T x = ll.pfirst->info; ll.removeFirst(); return x; } T peek() { if (isEmpty()) { fprintf(stderr, "Error 103 - The queue is empty!\n"); T x; return x; } return ll.pfirst->info; } int isEmpty() { return (ll.isEmpty()); } };

16 Maintenir une liste triée template class SortedLinkedList : public LinkedList { public: void addElement(T x) { struct list_elem *p, *paux; p = pfirst; while (p != NULL && p->info < x) p = p->next; if (p == NULL) addLast(x); else { paux = new struct list_elem ; paux->info = x; paux->next = p; paux->prev = p->prev; p->prev = paux; if (p->prev != NULL) p->prev->next = paux; else pfirst = paux; } };

17 Pour le prochain TP Pensez aux changements que vous avez à faire pour construire une liste linéaire liée individuellement ou une liste circulaire!