2 Exercices avec listes chaınées

IFT2015 Mikl´os Cs˝ur¨os 9 septembre 2013
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 S´ eparation et fusion
a b
Ncdefg
a
b
L0c
d
e
f
g
L1
split(N)fusion(L0,L1)
On veut une proc´ edure split(N)qui
s´ epare une liste simplement chaˆ ın´ ee
d´ ebutant avec le nœud Nen deux
listes contenant les nœuds originaux.
Pour cela, on prend les nœuds pen-
dant le parcours de la liste originale, et
on les ajoute ` a la fin des sous-listes en
alt´ ernant entre les deux.
On veut aussi l’op´ eration inverse fusion
qui fusionne deux listes, en prenant
leurs nœuds en alt´ ernant.
Dans les exercices suivants, on d´ etruit la liste ou les listes ` a l’entr´ ee pour placer
les nœuds sur autres listes. Ne cr´ eez aucun nouveau nœud.
S´ eparation r´ ecursive. IImplanter split par un algorithme r´ ecursif. L’algorithme
doit retourner une paire de nœuds L0, L1: pour la liste originale x0, x1, . . . , x`−1,
L0est la tˆ ete de la liste x0, x2, x4, . . . et L1est la tˆ ete de la liste des nœuds
x1, x3, x5, . . . .
S´ eparation it´ erative. IDonner une implantation sans r´ ecursion.
Indice: Vous aurez besoin de variables pour stocker les deux tˆ etes, et des curseurs pour stocker la fin des
deux sous-listes pendant la construction.
Fusion r´ ecursive. IDonner une implantation r´ ecursive de l’op´ eration fusion(L0, L1)
qui prend deux listes et retourne un troisi` eme qui contient tous les nœuds des listes
`
a l’entr´ ee. Si L0ou L1est null, l’algorithme retourne simplement l’autre liste. (Ainsi
on peut fusionner des listes de tailles diff´ erentes.)
2

X2.4 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.
3

X2.5 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.
4

X2.6 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 !
5