Structures de données et algorithmes – C5 - PowerPoint PPT Presentation

structures de donn es et algorithmes c5 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Structures de données et algorithmes – C5 PowerPoint Presentation
Download Presentation
Structures de données et algorithmes – C5

play fullscreen
1 / 17
Structures de données et algorithmes – C5
92 Views
Download Presentation
yama
Download Presentation

Structures de données et algorithmes – C5

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

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

  2. Objectifs • Listeslinéaireschainées • concepts et types de listes • Operations de base pour mettre en œuvre des listes • Piles et files d'attentemises en œuvre avec listeschainées • Autres applications avec listeschainé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 longueurde la liste – le nombre d'éléments dans la liste • ….

  5. Mises en œuvre avec…(1) • des listes linéairesliées individuellement, des listes linéairesdoublement 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 d’accè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) • listeslinéairesliées individuellement (singly-linked linear lists) • listes linéairesdoublement 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éairedoublement chaînée– Implementation (mylist.h) #include <stdio.h> #include <stdlib.h> #include <iostream.h> using namespace std; template<typename T> structlist_elem { T info; structlist_elem<T> *next, *prev; }; template <typename T> class LinkedList { public: structlist_elem<T> *pfirst, *plast;

  10. Listes linéairedoublement chaînée– Implementation (mylist.h) • void removeFirst() { • structlist_elem<T>* 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() { • structlist_elem<T> *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; • } void addFirst(T x) { structlist_elem<T> *paux; paux = new structlist_elem<T>; 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) { structlist_elem<T> *paux; paux = new structlist_elem<T>; paux->info = x; paux->prev = plast; paux->next = NULL; if (plast != NULL) plast->next = paux; plast = paux; if (pfirst == NULL) pfirst = plast; }

  11. void removeFirstOccurrence(T x) { • structlist_elem<T> *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) { • structlist_elem<T> *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; • } • } mylist.h structlist_elem<T>* findFirstOccurrence(T x) { structlist_elem<T> *paux; paux = pfirst; while (paux != NULL) { if (paux->info == x) return paux; paux = paux->next; } return NULL; } structlist_elem<T>* findLastOccurrence(T x) { structlist_elem<T> *paux; paux = plast; while (paux != NULL) { if (paux->info == x) return paux; paux = paux->prev; } return NULL; }

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

  13. list.cpp #include "mylist.h" int main() { LinkedList<int> 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éairechaînée template<typename T> class Stack { private: LinkedList<T> 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éairechaînée template<typename T> class Queue { private: LinkedList<T> 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. Maintenirunelistetriée template <typename T> class SortedLinkedList : public LinkedList<T> { public: void addElement(T x){ structlist_elem<T> *p, *paux; p = pfirst; while (p != NULL && p->info < x) p = p->next; if (p == NULL) addLast(x); else{ paux = new structlist_elem<T>; paux->info = x; paux->next = p; paux->prev = p->prev; p->prev = paux; if (p->prev != NULL)p->prev->next = paux; elsepfirst = paux; } } };

  17. Pour le prochain TP • Pensez aux changements que vous avez à faire pour construire une listelinéaireliée individuellement ou une liste circulaire!