structures de données et algorithmes – c5

Structures de données et algorithmes – C5

Maria-Iuliana Dascalu, PhDmariaiuliana.dascalu@gmail.com

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

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

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• ….

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

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

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)

Types de listes (2)• listes circulaires liées individuellement (singly-linked circular lists)

• listes circulaires doublement chaînées (doubly-linked circular lists)

Listes linéaire doublement chaînée– Implementation (mylist.h)

#include <stdio.h>#include <stdlib.h>#include <iostream.h>using namespace std;

template<typename T> struct list_elem { T info; struct list_elem<T> *next, *prev;};

template <typename T> class LinkedList { public: struct list_elem<T> *pfirst, *plast;

Listes linéaire doublement chaînée– Implementation (mylist.h)

void addFirst(T x) { struct list_elem<T> *paux;

paux = new struct list_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) { struct list_elem<T> *paux;

paux = new struct list_elem<T>; 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<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() { struct list_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; }

mylist.hstruct list_elem<T>* findFirstOccurrence(T x) { struct list_elem<T> *paux;

paux = pfirst; while (paux != NULL) { if (paux->info == x) return paux; paux = paux->next; } return NULL; } struct list_elem<T>* findLastOccurrence(T x) { struct list_elem<T> *paux;

paux = plast; while (paux != NULL) { if (paux->info == x) return paux; paux = paux->prev; }

return NULL; }

void removeFirstOccurrence(T x) { struct list_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) { struct list_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 int isEmpty() { return (pfirst == NULL); }

LinkedList() { pfirst = plast = NULL; }

void printList() {

struct list_elem<T> *p;

p = pfirst;while (p != NULL){

printf("%d\n", p->info);p = p->next;

} }

};

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;}

Pille avec listes linéaire chaînéetemplate<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());

}};

File d'attente avec listes linéaire chaî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()); }};

Maintenir une liste triéetemplate <typename T> class SortedLinkedList : public LinkedList<T> { public: void addElement(T x) { struct list_elem<T> *p, *paux;

p = pfirst; while (p != NULL && p->info < x) p = p->next;

if (p == NULL) addLast(x); else { paux = new struct list_elem<T>; paux->info = x; paux->next = p; paux->prev = p->prev;

p->prev = paux;

if (p->prev != NULL) p->prev->next = paux; else pfirst = paux; } }};

Pour le prochain TP

• Pensez aux changements que vous avez à faire pour construire une liste linéaire liée individuellement ou une liste circulaire!