Structures de données

CSI1502:
Principes fondamentaux de
conception de logiciels
Chapitre 12: Structures de données
Objectif d'apprentissage:
Structures de données


Quelques techniques pour l'organisation et la gestion
d'information
Comprendre:
 Collections dans Java
 Type de donnée abstraite / Abstract Data Types
(ADTs)
 Structures dynamiques et listes chaînées
 Structures de données linéaires: queues et piles
2
Qu'est-ce une
Collection?


Une collection est un objet qui sert à stocker autres
objets,
 e.g. collection d'étudiants, CD, magazines, nourriture
Une collection offre des services tels que l'addition,
l'enlèvement, et la gestion des éléments qu'elle contient
 Parfois les éléments dans une collection sont ordonnés,
parfois ils ne sont pas
 Parfois les collections sont homogènes, parfois elles sont
hétérogènes
3
Abstract Data Types:
Implementing a collection




Un type de donnée abstraite (ADT) est
 une collection d'information organizée et
 un ensemble d'opérations utilisé pour gérer cette information
L'ensemble d'opérations définit l'interface à l'ADT
On implémente un ADT utilisant une structure de donnée dynamique
 Une structure de donnée dynamique grandit et rétrécit lors de
l'exécution comme nécessaire
 Une structure de donnée dynamique est implémentée avec des
chaînes
Question: Est-ce qu'un Array est une structure de donnée dynamique?
4
Références d'objet:
Utilisé pour les ADTs


Une référence d'objet est une variable qui stocke
l'adresse de l'objet
 Une référence peut être appelé un pointeur
Les références sont souvent représentées comme
diagramme: student
John Smith
40725
3.58
Student john = new Student(“John Smith…”);
5
Références d'objet comme
chaînes

Supposons que la classe Student contient une référence à
un autre objet Student
John Smith
40725
3.57
Jane Jones
58821
3.72
class Student
{
STRecord info; // info about the student
Student next; // link to another Student object
}
Student john = new Student(“John Smith…”, null);
Student jane = new Student(“Jane Jones..”, null);
john.next = jane;
6
Références comme chaînes:
La liste chaînée

Les références peuvent être utilisé pour créer une variété
de structures chaînées, tel qu'une liste chaînée:
studentList
7
Le contenu des noeuds
(nodes) intermédiaires



Les objets stockés ne devraient pas avoir besoin de se concerner des
détailles des structures de données dans lesquelles ils sont stockés
 Par exemple, la classe Student ne devrait pas avoir besoin de
stocker le lien ou la chaîne au prochain objet Student object dans
la liste
Au lieu, on peut utiliser des classes noeuds (node class) séparées
avec deux parties:
 1) une référence à un objet indépendant et
 2) un lien au prochain noeud dans la liste
La représentation interne devient une liste chaînée de noeuds
8
Exemple: Une Collection
de Magazines



Voici un exemple d'une collection d'objet Magazine
La collection est gérée par la classe MagazineList, qui
contient une classe interne nommée MagazineNode
Puisque MagazineNode est private à MagazineList,
les méthodes de MagazineList peuvent accéder
directement aux informations de MagazineNode sans
violer l'encapsulation
info
info
info
next
next
next
9
MagazineRack.java
public class MagazineRack
{
// Creates a MagazineList object, adds several magazines to the
// list, then prints it.
public static void main (String[] args)
{
MagazineList rack = new MagazineList();
rack.add (new Magazine("Time"));
rack.add (new Magazine("Woodworking Today"));
rack.add (new Magazine("Communications of the ACM"));
rack.add (new Magazine("House and Garden"));
rack.add (new Magazine("GQ"));
}
}
System.out.println (rack);
10
MagazineList.java
public class MagazineList
{
private MagazineNode list;
// Sets up an initially empty list of magazines.
MagazineList()
{
list = null;
}
Continued….
11
MagazineList.java
// Creates a new MagazineNode object and adds it to the end of the linked list.
public void add (Magazine mag)
{
MagazineNode node = new MagazineNode (mag);
MagazineNode current;
if (list == null)
list = node;
else
{
current = list;
while (current.next != null)
current = current.next;
current.next = node;
} }
// we are at the list’s beginning
// walk through the list to the end
12
Continued….
MagazineList.java
// Returns this list of magazines as a string.
public String toString ()
{
String result = "";
MagazineNode current = list;
while (current != null)
{
result += current.magazine + "\n";
current = current.next;
}
}
return result;
Continued….
13
MagazineList.java
public class MagazineList
// An inner class that represents a node in the magazine list.
// The public variables are accessed by the MagazineList class.
private class MagazineNode
{
public Magazine magazine;
public MagazineNode next;
}
}
//-------------------------------------------------------------// Sets up the node
//-------------------------------------------------------------public MagazineNode (Magazine mag)
{
magazine = mag;
next = null;
}
14
Magazine.java
public class Magazine
{
private String title;
//----------------------------------------------------------------// Sets up the new magazine with its title.
//----------------------------------------------------------------public Magazine (String newTitle)
{
title = newTitle;
}
}
//----------------------------------------------------------------// Returns this magazine as a string.
//----------------------------------------------------------------public String toString ()
{
return title;
}
15
Collection Magazine

Une méthode appelée insert peut être défini pour
ajouter un noeud n'importe où dans la liste, pour la
garder trié, par exemple
info
info
info
next
next
next
newnode
info
next
16
Collection Magazine

Une méthode appelée delete peut être défini pour
enlever un noeud de la liste
info
info
info
next
next
next
17
Autres représentations pour
listes dynamiques

Parfois c'est convénient d'implémenter une liste
comme une liste chaînée double, avec des références
next et previous
list
18
Autres implémentations pour
listes dynamiques

Parfois c'est convénient d'utiliser un header node séparé,
avec un count et des références à la tête (front) et la
queue (rear) de la liste
list
count: 4
front
rear
19
Autres implémentations pour
listes dynamiques



Une liste chaînée peut être une liste circulaire, où le dernier élément de
la liste est lié au premier élément de la liste
Si la liste chaînée est doublement chaînée, le premier élément dans la
liste est aussi lié au dernier élément de la liste
Choix pour faire les liens:
 La représentation doit
 faciliter les opérations et
 les rendre facile à implémenter
20
Autres structures de donnée
classiques



Structures de donnée linéaires classiques, les queues et les
piles
Structures de donnée non-linéaires classiques, y compris
les arbres, les arbres binaires, les graphes et les digraphes
CSI2514 présente les structures de donnée en plus de
détailles
21
Structure de donnée linéaire 2:
Queues





Une queue est similaire à une liste mais ajoute des
éléments seulement à la fin de la liste et enlève des
éléments seulement au début de la liste
Ce s'appelle une structure de donnée FIFO: First-In, FirstOut
Analogie:
 une ligne d'attente à la banque
Utilisé très souvent dans les systèmes opérationnelles
Les queues sont souvent utiles dans les simulations ou les
situations où des éléments sont sauvegardés en attendant
d'être traité enqueue
dequeue
22
Queues (suite)


On peut définir des opérations pour la queue
 enqueue - ajoute un élément à la fin de la queue
 dequeue (ou serve) - enlève un élément du début de la
queue
 empty - retourne vrai (true) si la queue est vide
Une queue peut être représenté par une liste chaînée
simple (singly-linked list); c'est plus performant si les
références sont liées du début vers la fin de la queue
23
Structure de donnée linéaire 2:
Piles



Un type de donnée abstraite pile est aussi linéaire, comme
une liste ou une queue
Les éléments sont ajoutés et enlevés d'un bout de la pile
seulement
C'est donc LIFO: Last-In, First-Out
push

pop
Analogies:
 une pile d'assiettes dans un placard,
 une pile de factures à payer,
 ou une pile de balles de foin
dans une grange
24
Piles (suite)



Quelques opérations pour les piles:
 push - ajoute un élément au sommet de la pile
 pop - enlève un élément du sommet de la pile
 peek (or top) - extrait l'élément au sommet de la
pile sans l'enlever de la pile
 empty - retourne vrai (true) si la pile est vide
Le package java.util contient une classe Stack
Voir Decode.java (page 649)
25
Decode.java
import java.util.Stack;
import cs1.Keyboard;
public class Decode
{
// Decodes a message by reversing each word in a string.
{
public static void main (String[] args)
Stack word = new Stack();
String message;
int index = 0;
System.out.println ("Enter the coded message:");
message = Keyboard.readString();
System.out.println ("The decoded message is:");
Continued…
26
Decode.java (cont)
while (index < message.length())
{
// Push word onto stack
while (index < message.length() && message.charAt(index) != ' ')
{
word.push (new Character(message.charAt(index)));
index++;
}
}
}
}
// Print word in reverse
while (!word.empty())
System.out.print (((Character)word.pop()).charValue());
System.out.print (" ");
index++;
System.out.println();
Enter the coded message:
Hello world
The decoded message is:
olleH dlrow
27
Structures de donnée en Java:
Classes Collection

La librairie standard de Java contient plusieurs classes pour
représenter des collections, souvent référé comme Java
Collections API


Leur implémentation est sous-entendue dans les noms de
classes tels que ArrayList et LinkedList
Plusieurs interfaces sont utilisées pour définir les opérations
sur les collections, telles que List, Set, SortedSet,
Map, et SortedMap
28
Sommaire:
Chapitre 12

Comprendre:
 Collections dans Java
 Type de donnée abstraite / Abstract Data Types
(ADTs)
 Structures dynamiques et listes chaînées
 Structures de donnée linéaires: queues et piles
29