2 Exercices avec listes chaınées

IFT2015 Mikl´os Cs˝ur¨os 22 octobre 2012
2 Exercices avec listes chaˆ ın´ ees
Notation. Sauf si autrement sp´ ecifi´ e, les exercices suivants repr´ esentent une liste
comme un ensemble de nœuds : chaque nœud x(sauf le nœud terminal x=null)
contient les variables x.next (prochain ´ el´ ement) et x.val (contenu : ´ el´ ement stock´ e).
X2.1 ´ Echange d’´ el´ ements
IMontrer le code pour l’algorithme EXCHANGE(N)qui ´ echange deux nœuds
suivant N.IMontrer le code pour l’algorithme EXCHANGEVAL(N)qui ´ echange
le contenu des deux nœuds suivant N.
B C ...
B C ...
N
B C ...
C B ...
N
échange de
noeuds échange de contenu
L’algorithme peut assu-
mer qu’il y a au moins
deux nœuds apr` es N.
X2.2 Recherche s´ equentielle
On veut un algorithme SEARCH(N, x)qui retourne le premier nœud Mavec
M.val =xsur la liste d´ ebutant avec nœud N. Si aucun nœud ne contient x,
l’algorithme doit retourner null.
Recherche r´ ecursive. IDonner une implantation r´ ecursive de SEARCH(N, x).
QWERTYUI
head
search(Y)
YQWERTUI
head
La heuristique MTF (move-to-front) d´ eplace
l’´ el´ ement trouv´ e` a la tˆ ete. Lors d’une re-
cherche infructueuse, la liste ne change pas.
La heuristique est utile quand on cherche
des ´ el´ ements avec des fr´ equences diff´ erentes
car les ´ el´ ements souvent recherch´ es se
trouvent vers le d´ ebut de la liste pendant
une s´ erie d’appels.
Move-to-front. IMontrer l’implantation de SEARCH(N, x)qui performe la
recherche s´ equentielle pour une cl´ exsur la liste chaˆ ın´ ee d´ ebutant avec Nselon la
heuristique MTF.
1

X2.3 Rotations
On veut une structure qui supporte des rotations d’´ el´ ements sur une liste. Soit
x0, x1, . . . , x`−1l’ordre des nœuds sur la liste (x0est le premier nœud). Les
op´ erations suivantes changent l’ordre des ´ el´ ements x0, . . . , xn−1avec n≤`. En
une rotation avant (rotF), on avance les nœuds x1, . . . , xn−1vers la tˆ ete et on
place x0apr` es xn−1. En une rotation arri` ere (rotR), les nœuds x0, . . . , xn−2re-
culent vers la queue et xn−1se place ` a la tˆ ete. En un d´ ecalage circulaire (roll) on
performe plusieurs rotations avant ou arri` ere.
Op´ eration R´ esultat
rotF(n)x1, x2, . . . , xn−1, x0,xn, xn+1, . . . , x`−1
| {z }
ne change pas
rotR(n)xn−1, x0, x1, . . . , xn−2,xn, xn+1, . . . , x`−1
| {z }
ne change pas
roll(n, j)xjmod n, x(jmod n)+1, . . . , xn−1, x0, x1, . . . , x(jmod n)−1,xn, . . . , x`−1
|{z }
ne change pas
012 456 ...
head
roll(7, 3)
37
345 012
head 67...
roll(7, -3)
123 056
head
rotF(5)
47
rotR(5)
...
L’op´ eration roll(n, j)correspond
`
ajrotations avant (si j > 0)
rotF ou |j|rotations arri` ere (si
j < 0)rotR. On r´ etablit l’ordre
original par l’op´ eration inverse
roll(n, −j) = roll(n, n −j).
IMontrez comment implanter les op´ erations rotF(H, n),rotR(H, n), et roll(H, n, j)
sur une liste simplement chaˆ ın´ ee. L’argument Hd´ enote le d´ ebut de la liste : on ap-
pelera p.e., head ←rotF(head,10).
Indice: Il n’est pas n´ ecessaire de performer jrotations pour implanter roll. Identifiez plutˆ ot les nœuds o` u
.next doit changer.
2

X2.4 Pair-impair
On veut une proc´ edure deleteOdd(N)qui supprime les nœuds avec cl´ es im-
paires ` a partir de Net retourne la nouvelle tˆ ete de la liste. L’algorithme doit
pr´ eserver l’ordre des nœuds qui restent. Montrez tous les d´ etails de vos algorithmes
(p.e., il ne suffit pas de dire «suppression apr` es x», il faut montrer les affectations
exactes).
21463
2 4 6
N
deleteOdd(N)
1963
6
deleteOdd(N)
N
Exemples du fonctionnement de deleteOdd : on retourne une r´ ef´ erence au nœud ombr´ e.
a. Solution it´ erative. IDonnez une implantation it´ erative de deleteOdd.
b. Solution r´ ecursive. IDonnez une implantatation r´ ecursive de deleteOdd.
c. R´ ecursion terminale. IDonnez une implantation avec r´ ecursion terminale.
3

X2.5 Arithm´ etique binaire
1101101
head
n=91
0011101
head
n=92
increment()
On veut une structure de donn´ ees pour
repr´ esenter des entiers positifs de gran-
deur arbitraire. Pour cela, on utilise une
liste chaˆ ın´ ee de bits. Un nœud xde la
liste chaˆ ın´ ee contient donc un bit dans
x.val (qui prend la valeur 0 ou 1).
La tˆ ete de la liste (head) est le nœud pour le bit de poids faible. On repr´ esente le
nombre n= 0 par une liste comportant un seul nœud xdont x.bit = 0. Un
nombre n > 0avec 2k−1≤n < 2kest repr´ esent´ e par une liste de longueur k:
n=Pk−1
i=0 (xi.bit)·2io`
uxiest le i-` eme nœud apr` es la tˆ ete.
IDonnez une implantation de l’op´ eration increment(head)qui incr´ emente
(par un) le nombre repr´ esent´ e. L’algorithme doit mettre ` a jour la liste (au lieu
de cr´ eer une autre liste). Analysez la croissance asymptotique du temps de cal-
cul au pire cas en fonction de la valeur incr´ ement´ ee n. Est-ce qu’on peut dire
que votre algorithme prend un temps lin´ eaire (dans la taille de l’argument n) ?
Justifiez votre r´ eponse.
ID´ emontrez que le temps amorti de increment est O(1) dans votre implan-
tation.
Indice: Ici, il faut montrer que le temps total T(n)pour nappels de increment() (apr` es lesquels
la liste repr´ esente n) est born´ e par T(n)/n =O(1). Dans d’autres mots, mˆ eme si increment() ne
prend pas toujours O(1), compter jusqu’` anprend O(n)temps. Examinez donc comment le contenu
des nœuds change quand on compte jusqu’` an.
IDonnez un algorithme add(A, B)qui calcule la repr´ esentation de a+b` a
partir de leur repr´ esentations par liste. L’argument A(B) donne le premier
nœud contenant le bit de poids faible pour la liste de a(b).
IDonnez une implantation de increment pour l’encodage Fibonacci. Dans cet
encodage, une liste de longueur krepr´ esente le nombre n=Pk−1
i=0 (xi.bit)·
F(i+ 2), o` uF(i)est le i-` eme nombre Fibonacci. (Rappel : F(0) = 0,
F(1) = 1.) Notez que la repr´ esentation Fibonacci n’est pas unique : par
exemple, 19 = 101001 = 11111 car 19 = 13 + 5 + 1 = 8 + 5 + 3 + 2 + 1.
Indice: La cl´ e est d’utiliser la repr´ esentation de poids minimal : c’est celle qui minimise Pixi.bit.
On y arrive en remplac¸eant chaque suite 011 par 100 (possible car F(i) = F(i−2) + F(i−1)).
Examinez d’abord comment peut-on g´ en´ erer la repr´ esentation minimale en parcourant la liste : si on a
0,1,1(de la tˆ ete vers la queue), alors remplacer par 1,0,0. Attention, le remplacement peut cr´ eer une
suite 0,1,1voisine !
4