EXERCICE 1 :

Dans un multi ensemble un élément peut se répéter plusieurs fois.

Exemple :

M = {1,2,3,3,1,1,4,1,5,5,6}
est un multi ensemble d’entiers.
On s’intéresse dans cet exercice aux multi ensembles sur les entiers.

On peut représenter un multi ensemble par une liste chaînée simple définie par :

R1 = ^ nœud

nœud = enreg
val : entier
suiv : R1
fenreg

1) Ecrire une fonction qui étant donné un multi ensemble d’entiers M représenté selon R1 et
un entier X calcule la fréquence (le nombre d’apparitions) de X dans M.

Fréquence(L :R1 ; x : entier) :entier

Var p : R1
N : entier
Debut
N := 0
p := L
Tant que p < > NIL faire
Si p^.val = x
Alors N := N + 1
fsi
p := p ^. suiv
fait
Fréquence:= N
Fin

2) Proposer une autre représentation R2 des multi ensembles sur les entiers, basée sur les
listes chaînées et évitant les redondances d’éléments.

R2 = ^ nœud2

nœud2 = enreg
val : entier
nb_occ : entier // nombre d’apparition
suiv : R2
fenreg
3) Ecrire une procédure qui étant donné un multi ensemble d’entiers représenté selon R1
fournira le même multi ensemble représenté selon R2.
 De_R1_Vers_R2(L1 :R1 ; var L2 : R2)
Var p : R1
q : R2
Debut
L2 := NIL
p := L
Tant que p < > NIL faire
q := existe(L2,p^.val)
si q ≠ NIL
alors q^.nb_occ := q^.nb_occ + 1
sinon créer(q)
q^.val := p^.val
q^.nb_occ := 1
q^.suiv := L2
L2 := q
fsi
p := p ^. suiv
fait

Fin

Exercice 2 :
On considère une liste chaînée circulaire d'entiers de la forme suivante : L

4 10 7 12

Dans une telle liste, le pointeur L permet d'accéder au dernier nœud de la liste (au lieu du
premier). Cette organisation simplifie les insertions en tête et en queue. On remarque que la
tête de la liste (le noeud contenant 4) est accédée par le champ next du dernier nœud (le nœud
contenant 12).

1) Ecrire une fonction qui calcule le nombre de nœuds d’une telle liste.

Nb_noeuds(L :LS) :entier

Var p : LS
N : entier
Debut
N := 0
Si L < > NIL
Alors p := L
N := 1
Tant que p < > L faire
N := N + 1
p := p ^. next
fait
fsi
Nb_noeuds := N
Fin
 2) Ecrire la procédure insère_tête, permettant d’insérer une valeur donnée en tête d’une
telle liste.

Insère_tête( var L : LS ; x : valeur)

Var p : LS
Debut
Créer(p)
p ^. val := x
Si L = NIL
Alors L := p
Sinon p ^.next := L^.next
Fsi
L^.next := p
Fin

3) Ecrire la procédure insère_queue, permettant d’insérer une valeur donnée en queue

d’une telle liste.

Insère_queue( var L : LS ; x : valeur)

Var p : LS
Debut
Créer(p)
p ^. val := x
Si L = NIL
Alors p^.next := p
Sinon p ^.next := L^.next
L^.next := p
Fsi
L := p
Fin

Exercice 3 :
On s’intéresse à la fusion de listes ordonnées. On est en présence de k suites de nombres
ordonnées de façon décroissante, et on veut les fusionner en une seule suite croissante.
A chaque étape, on considère le premier élément de chacune des k listes (c'est le plus grand
dans chaque liste). Le maximum de ces nombres est inséré dans la liste résultat, et supprimé
de la liste dont il provient. On répète ce processus jusqu’à ce que toutes les listes soient vides.
Pour ce faire, on stocke les adresses des têtes de listes (k adresses) dans un tableau de taille
maximale MAX (Figure 1). Quand une liste devient vide l’élément correspondant dans le
tableau y sera supprimé.

1) Définir la structure TAB_LISTE permettant de représenter les listes à fusionner par un

tableau de listes chaînées.
 TAB_LISTE = tableau [ 1 .. MAX ] de LS
LS = ^nœud
noued = enreg
val : entier
next : LS
fenreg

2) Ecrire une fonction qui retourne l’indice, dans le tableau, de la liste contenant le plus
grand élément. Pour l’exemple de la Figure 1, la fonction retournera la valeur 3.

1 2 3 4 5 6 7

80 60 90 40 57 15 85

70 30 20 39 46 10 66
NIL NIL

50 25 3 8
NIL

35 23 1
NIL

28 12
NIL

19
NIL

Figure 1 : un tableau de 7 listes décroissantes

Pos_plus_gd ( T : TAB_LISTE ; k : entier ) : entier

Var i , pos : entier
Debut
pos := 1
pour i de 2 à k faire
Si T[i]^.val > T[pos]^.val
Alors pos := i
Fsi
Fpour
Pos_plus_gd := pos
Fin

3) Ecrire une procédure qui supprime le plus grand élément de la liste dont il provient. Si
la liste devient vide, on la supprimera du tableau.
 Supp_plus_gd ( var T : TAB_LISTE ; var k : entier ) : entier
Var pos : entier
Debut
pos := Pos_plus_gd ( T , k )
Supp_plus_gd := T[pos]^.val
supprime_tête( T[pos] )
Si T[pos] = NIL
Alors T[pos] := T[k]
K := k-1
Fsi
Fin

4) Ecrire une procédure qui construit une liste ordonnée dans un ordre croissant à partir
de k listes ordonnées de façon décroissante et représentées par un tableau de type
TAB_LISTE.

Liste_croissante (T : TAB_LISTE ; k : entier ; var L : LS)

Var
Debut
L := NIL
Tant que k > 0 faire
x := Supp_ plus_gd ( T , k )
insere_tête( L , x )
fait
Fin