1521. Motd
ITI Introduction ` linformatique II a
Marcel Turcotte Ecole dingnierie et de technologie de linformation e Version du 18 mars 2010 Rsum e e Listes cha ees (partie 2) n Pointeur arri`re e Listes doublement cha ees n Noeud factice (dummy node)
David Cummings, a programmer who worked on the Mars Pathnder project, has written an interesting editorial in the L.A. Times encouraging Toyota to drop claims of software infallibility in their recent acceleration problems. He argues that embedded systems developers must program more defensively, and that companies should stop relying on software for safety. Quoting : If Toyota has indeed tested its software as thoroughly as it says without nding any bugs, my response is simple : Keep trying. Find new ways to instrument the software, and come up with more creative tests. The odds are that there are still bugs in the code, which may or may not be related to unintended acceleration. Until these bugs are identied, how can you be certain they are not related to sudden acceleration ? L.A. Times, 2010-03-11
. Ces notes de cours ont t conues an dtre visualiser sur un cran dordinateur. ee c e e
Temps dexcution e
Comparons lecacit des implmentations ` base de tableaux (ArrayList) et ` e e a a base de listes cha ees (LinkedList) (toutes deux peuvent contenir un nombre n illimit dobjets, donc ArrayList utilise un tableau dynamique). e Nous dirons que le temps dexcution est variable (lent) si le nombre doprations e e varie selon le nombre dlments prsentement sauvegards dans la structure de ee e e donnes, et constant (rapide) sinon. e
Temps dexcution e
Pouvez-vous dj` prdire laquelle des deux implmentations sera la plus rapide ? ea e e void addFirst( E o ) void addLast( E o ) void add( E o, int pos ) E get( int pos ) void removeFirst() void removeLast() ArrayList variable variable variable constant variable constant LinkedList constant variable variable variable constant variable
Pour certaines oprations, lorsque lune des implmentations est rapide, lautre e e est lente ; En regardant le tableau ci-haut, quand devrait-on utiliser une implmentation e ` base de tableaux ? Pour les acc`s directs (alatoires) en lecture ; a e e Quand devrait-on utiliser une liste cha ee ? Si tous les acc`s se font au dbut n e e de la liste ; Quelle implmentation consomme plus de mmoire ? e e
Acclrer addLast pour une liste simplement cha ee ee n
Il y a une technique dimplmentation simple permettant dacclrer lajout ` e ee a larri`re dune liste cha ee. e n Quest-ce qui rend limplmentation actuelle coteuse ? e u Oui, il faut parcourir la liste dun bout ` lautre an dajouter llment ` la toute a ee a n. On pourrait bien sr ajouter les lments dans lordre inverse, mais a ne ferait u ee c que dplacer le probl`me, la mthode addFirst() serait lente. e e e Pour la mthode size(), nous avons vu que lutilisation dune variable dinstance e supplmentaire, count, pouvait nous viter de parcourir la liste inutilement. e e Que nous faudrait-il dans ce cas-ci pour viter un parcours ? e Oui une nouvelle variable dinstance pointant sur le dernier lment de la liste. ee
Reprsentation de la liste vide : e
head
tail
Cas gnral : ee
10:10:00 11:00:00 12:12:00 9:59:45
head
value next
value next
value next
value next
tail
index.pdf
March 18, 2010
1
public class LinkedList<E> implements List<E> { private static class Node<T> { private E value; private Node<T> next; private Node( T value, Node<T> next ) { this.value = value; this.next = next; }
public void addLast( E o ) { Node<E> newNode = new Node<E>( t, null ); if ( head == null ) { head = newNode; tail = head; } else { tail.next = newNode; tail = tail.next; }
}
}
private Node<E> head; private Node<E> tail; } // ...
On a ajout une variable dinstance, tail. e
public E removeFirst() { Node<E> nodeToDelete = head; E result = nodeToDelete.value; head = head.next; noteToDelete.value = null; // scrubbing noteToDelete.next = null; if ( head == null ) { tail = null; } } return result;
Temps dexcution (rvision 1) e e
void addFirst( E o ) void addLast( E o ) void add( E o, int pos ) E get( int pos ) void removeFirst() void removeLast() ArrayList variable variable variable constant variable constant LinkedList constant constant variable variable constant variable
Discussion : cette modication a-t-elle un impact (favorable) sur la vitesse dexcution de la mthode removeLast() ? e e Non, aucun impact signicatif.
Toutes les mthodes sont modies en consquence. e e e
Acclrer removeLast() ee
Le pointeur tail ne nous aide en rien pour lopration removeLast, il nous faut e encore parcourir toute la liste.
10:10:00 11:00:00 12:12:00 9:59:45
Acclrer removeLast() ee
l A h e ad p rev i o u s B C D
head
value next
value next
value next
value next
ta il
tail
nodeBeforeTheLast
Quen pensez-vous ? Quest-ce quil nous faut ? Que pensez-vous dune nouvelle variable dinstance previous ?
index.pdf
March 18, 2010
2
Acclrer removeLast() ee
l A h e ad B C D
Nous devons accder ` llment qui prc`de le dernier : e a ee ee
10:10:00 11:00:00 12:12:00 9:59:45
head
value next
value next
value next
value next
p rev i o u s ta il
tail
Dplacer la rfrence arri`re est maintenant facile et rapide ! e ee e Sauf que le dplacement de la rfrence previous est dicile et coteux. e ee u
Mais aussi ` tous ses prdcesseurs ! a ee
10:10:00
head
tail
head
value prev next
Liste vide :
tail
Singleton :
10:10:00 11:00:00 12:12:00 9:59:45
head
value prev next
value prev next
value prev next
value prev next
tail
public class DoublyLinkedList<E> implements List<E> { private static class Node<T> { private T value; private Node<T> previous; // <--private Node<T> next; private Node( T value, Node<T> previous, Node<T> next ) { this.value = value; this.previous = previous; // <--this.next = next; } } private Node<E> head; private Node<E> tail; public LinkedList() { head = tail = null; } // ... } Cest une liste doublement cha n
Cas ee. gnral : ee
removeLast() (cas spcial : singleton) e
removeLast() (cas gnral) ee
index.pdf
March 18, 2010
3
public E removeLast() { // pre-condition: ? Node<E> toDelete = tail; E savedValue = toDelete.value; if ( head.next == null ) { head = null; tail = null; } else { tail = tail.previous; tail.next = null; } toDelete.value = null; toDelete.next = null; } return savedValue;
Temps dexcution (rvision 2) e e
void addFirst( E o ) void addLast( E o ) void add( E o, int pos ) E get( int pos ) void removeFirst() void removeLast() ArrayList variable variable variable constant variable constant LinkedList constant constant variable variable constant constant
removeLast() sans parcours de la liste.
Simple ? Pas si simple ?
Presque toutes les mthodes ont un ou des cas particuliers. e Pr-conditions ? e
add( int pos, E o )
if ( o == null ) { throw new IllegalArgumentException( "null" ); } if ( pos < 0 ) { throw new IndexOutOfBoundsException( Integer.toString( pos ) ); }
add( int pos, E o )
Cas spcial (spciaux) ? e e
l B h e ad ta il C h e ad ta il
add( int pos, E o )
Cas spcial : head = new Node<E>( o, null, head ) e
l A B C
Ajout en position 0.
Quest-ce qui manque ?
index.pdf
March 18, 2010
4
add( int pos, E o )
Cas spcial : head.next.previous = head e
l A h e ad ta il B C
add( int pos, E o )
Cas spcial : e if ( pos == 0 ) { head = new Node<E>( o, null, head ); head.next.previous = head; } Avons nous pensez ` tous les cas possibles ? a Et si la liste tait vide ? e
add( int pos, E o )
Cas spcial : e if ( pos == 0 ) { head = new Node<E>( o, null, head ); if ( tail == null ) { tail = head; } else { head.next.previous = head; }
add( int pos, E o )
Cas gnral : ajout en position 2 ee
l A h e ad ta il B D
}
add( int pos, E o )
Cas gnral : traversons la liste jusqu` pos-1 ee a
l A h e ad ta il p B D h e ad ta il
add( int pos, E o )
Cas gnral : q = p.next ee
l A B D
p
q
index.pdf
March 18, 2010
5
add( int pos, E o )
Cas gnral : p.next = new Node<E>( o, p, q ) ee
l A h e ad ta il p q B B D h e ad ta il
add( int pos, E o )
Cas gnral : q.previous = p.next ee
l A B B D
p
q
add( int pos, E o )
Cas gnral : ee Node<E> p = head; for ( int i = 0; i < (pos-1); i++ ) { p = p.next; } Node<E> q = p.next; p.next = new Node<E>( o, p, q ); q.previous = p.next; Avez-vous pensez ` tous les cas ? a Et si pos tait trop plus grand ? e Cas gnral : ee
add( int pos, E o )
Node<E> p = head; for ( int i = 0; i < (pos-1); i++ ) { if ( p == null ) { throw new IndexOutOfBoundsException( Integer.toString( pos ) ); } else { p = p.next; } } Node<E> q = p.next; p.next = new Node<E>( o, p, q ); q.previous = p.next; Avez-vous pensez ` tous les cas ? a Et si lajout se faisait en derni`re position ? e
add( int pos, E o )
Node<E> p = head; for (int i = 0; i < (pos-1); i++) { if ( p == null ) { throw new IndexOutOfBoundsException( Integer.toString( pos ) ); } else { p = p.next; } } Node<E> q = p.next; p.next = new Node<E>( o, p, q ); if ( p == tail ) { tail = p.next; } else { q.previous = p.next; }
Noeud factice
La technique dimplmentation suivante permet dliminer plusieurs cas spciaux. e e e La technique utilise un noeud factice (dummy node) ne contenant pas dlment. ee De plus, la liste est circulaire.
index.pdf
March 18, 2010
6
Noeud factice
Liste vide :
l
public class LinkedList<E> implements List<E> { private static class Node<T> { private T value; private Node<T> next; private Node( T value, Node<T> next ) { this.value = value; this.next = next; } } private Node<E> head; public LinkedList() { head = new Node<E>( null, null ); // <--head.next = head; // <--} // ...
h e ad
Cas gnral : ee
l B h e ad D F
}
// Ajout dans une liste simplement chaine (sans noeud factice) e public void addLast( E o ) { Node<E> newNode = new Node<E>( o, null ); if ( head == null ) head = newNode; else { Node<E> p = head; while ( p.next != null ) { p = p.next; } p.next = newNode; } }
Noeud factice (addLast)
Le nouvel lment sera ajout apr`s un noeud tel que . . . ee e e
l
h e ad
l B h e ad D F
// Noeud factice public void addLast( E o ) { Node<E> p = head; while ( p.next != head ) { p = p.next; } p.next = new Node<E>( t, head ); }
Remarques (noeud factice)
Quest-ce qui complique limplmentation des mthodes dune liste cha ee sans e e n noeud factice ? Les mthodes ont gnralement un cas spcial pour les modications en premi`re e ee e e position. En gnral, il faut changer la variable next du noeud qui prc`de, sauf si lon ee ee traite le premier noeud, il faut alors changer la variable head. Pour limplmentation ayant un noeud factice, les traitements sont uniformes, on e change toujours la variable next du noeud qui prc`de. ee Les noeuds de la liste peuvent aussi tre doublement cha es. On peut aussi e n ajouter une variable an de compter le nombre dlments. ee
index.pdf
March 18, 2010
7
l
l B h e ad s ize 0 h e ad s ize 1
Collection
En Java, les classes utilises pour sauvegarder des lments sont regroupes dans e ee e une hirarchie dont la racine est Collection. e Les collections sont linaires, hirarchiques, arborescentes ou non ordonnes. e e e Les collections linaires sont les listes, piles et les. Tous les lments ont un e ee prdcesseur et un successeur (` lexception du premier et du dernier lment). ee a ee Les arborescences permettent de reprsenter des arbres et des structures e hirarchiques. e
l B h e ad s ize 3 D F
Les graphes permettent de reprsenter les distances entre les villes, par exemple. e Les collections non ordonnes incluent les ensembles et les tables de hashage. e
l A h e ad ta il B C D
l
h e ad
l B h e ad D F
head
value prev next
10:10:00
11:00:00
12:12:00
9:59:45
head
value prev next
value prev next
value prev next
value prev next
10:10:00
11:00:00
12:12:00
9:59:45
head
value value prev next prev next prev next prev next prev next value value value
index.pdf
March 18, 2010
8