Problème de révision

On souhaite informatiser la gestion journalière du bloc opératoire dans une

clinique. Un bloc opératoire est représenté par une liste des salles.
Une salle est caractérisée par un numéro unique (entier), nombre
d’opérations (entier) et un tableau d’opérations dont la taille maximale est
Tmax puisque le nombre d’opérations dans une salle pour une journée ne
peut pas dépasser Tmax.
Une opération est caractérisée par un code (chaîne), le nom du chirurgien
(chaîne) et un état (entier) qui peut être égal à : 0 (finie) ou 1 (en cours) ou 2
(en attente).
On se propose de représenter le bloc opératoire par une liste doublement
chaînée de salles et dans chaque salle, on va planifier l’ensemble des
opérations dans un tableau statique d’opérations.
1. Déclarer les structures de données nécessaires pour représenter le bloc
opératoire.

@du precedent Valeur : salle @suivant

Salle : enregistrement contient un num un entier, nbop un entier, un tableau d’opérations (une opération =
enregistrement contient code : entier, nom :chaineetat :entier

Constante Tmax =30

Operation = enregistrement
Cod : chaine
Nom_ch :chaine
Etat :entier
Fin enregistrement

Type tab =tableau [1..Tmax] d’operation

1
Salle = enregistrement
Num_s :entier
Nb_op :entier
T_op : tab
Fin enregistrement
Cellule = enregistrement
Val : salle
Suivant : * cellule
Precedent : *cellule
Fin enregistrement

LD = enregistrement
Tete : *cellule
Queue : *cellule
Fin enregistrement

Sachant que L la liste des salles est triée selon l’ordre croissant des numéros
des salles, développer les sous programmes suivants :

2. La fonction créerSalle (nbOp: entier): Salle qui permet de remplir les

données d’une salle dont le nombre des opérations est égal à nbOp.
CréerSalle (nbop : entier) :salle
Salle = enregistrement
Var S : salle
Num_s :entier
I : entier
Nb_op :entier
Début
T_op : tab
Ecrire (‘’donner le num de la salle’’)
Fin enregistrement
2
Lire (S.Num_s)
S.nb_op <- nbop
Pour i allant de 1 à nbop faire
Ecrire (‘’donner le code de l’opération’’)
Lire (S.T_op[i].cod)
Ecrire (‘’donner le nom du chirurgien’’)
Lire (S.T_op[i].nom_ch)
Répéter
Ecrire (‘’donner l’état’’)
Lire (S.T _op[i].etat)
Jusqu’à (S.T _op[i].etat >=0 et S.T _op[i].etat <=2)
Fin pour
CréerSalle <-S
fin

3. La fonction chercherSalle (L: LD, NumS: entier): *cellule qui permet de

retourner un pointeur sur l’élément de la liste L contenant la salle dont
le numéro NumS est passé en paramètre et NULL si la salle n’existe pas.
Solution 1
Fonction chercherSalle (L : LD, NumS :entier) : *cellule
Var p : *cellule
Début 10 20 30

Si ( L.tete =L.queue=NULL) alors

Ecrire (‘’liste vide’’) Nouv num=15 p = NULL

p<- NULL
Sinon
p <- L.tete
Tant que (p<> NULL et NumS <> p->val.Num_S) faire
3
 P <- p->suivant // ou bien (*p).suivant
Fin TQ
finsi
ChercherSalle <- p
Fin

Solution 2
Fonction chercherSalle (L : LD, NumS :entier) : *cellule
ar p : *cellule 15 50

Début q

Nouv num= 5 p = L.tete

Si ( L.tete =L.queue=NULL) alors
Nouv num= 45 p = NULL
Ecrire (‘’liste vide’’)
Nouv num=1 5 p = @ de la cellule contenant 20
p<- NULL
Sinon
p <- L.tete
Tant que (p<> NULL et NumS > p->val.Num_S) faire
p <- p->suivant // ou bien (*p).suivant
Fin TQ
finsi
Si (NumS = p->val.Num_S)
ChercherSalle <- p
Sinon
chercherSalle <- NULL
finsi
Fin

4
4. La fonction AjouterSalle (L : LD, S: Salle): LD qui permet d’ajouter, si
c’est possible, une nouvelle salle S dans la liste L tout en respectant que
la liste est triée dans l’ordre croissant des numéros des salles. Avant
d’insérer la nouvelle salle S, on doit tout d’abord vérifier si elle existait
déjà dans la liste ou non.

5
Fonction ajout_tete(L : LD, S : Salle) : LD Fonction ajout_queue(L : LD, S : Salle) : LD
Var nouv : *cellule Var nouv : *cellule
Début Début
Nouv <- allouer (taille (cellule)) Nouv <- allouer (taille (cellule))
Nouv -> val <- S Nouv -> val <- S
Nouv->precedent <- NULL Nouv->precedent <- L.queue
Nouv ->suivant <- L.tete Nouv ->suivant <- NULL
Si (L.tete = L.queue =NULL) Si (L.tete = L.queue =NULL)
L.tete <- nouv L.tete <- nouv
L.queue <- nouv L.queue <- nouv
Sinon Sinon
L.tete ->precedent <- nouv L.queue -> suivant <- nouv
L.tete <- nouv L.queue <- nouv
Finsi Finsi
Ajout_tete <- L Ajout_queue <- L
fin fin

Fonction AjouterSalle (L :LD , S : Salle) : LD

Var nouv , p, q: *cellule
Début
p <- chercherSalle (L , S.Num_S) 
si (p <> NULL) alors
écrire (‘’salle existante, pas d’ajout’’)
sinon // faire l’ajout
si (L.tete = L.queue =NULL) alors
L <- ajout_tete(L , S ) 
6
 Sinon
q <- L.tete
Tant que (q<> NULL et NumS > q->val.Num_S) faire
q <- q->suivant
Fin TQ
Si (q =L.tete ) alors
L <- ajout_tete(L , S ) 
Sinon
Si (q =NULL) alors
L <- ajout_queue(L , S ) 
Sinon
Nouv <- allouer (taille (cellule))
Nouv -> val <- S
Nouv -> suivant <- q
Nouv -> precedent <- q -> precedent
q->precedent -> suivant <- nouv
q -> precedent <- nouv
finsi
finsi
finsi
finsi
AjouterSalle <- L
fin

7
Considérons maintenant une Pile de salles. On se propose de remplir cette Pile
par toutes les salles dont toutes les opérations sont terminées.

5. Déclarer la structure Pile de salles.

Element = enregistrement
Info : salle
Next : * element
Fin enregistrement
Pile = *element

6. Écrire la fonction SupprimerSalle (L: LD, NumS: entier):LD qui permet de

supprimer de la liste L une salle dont le numéro est NumS. Avant de
supprimer la salle mentionnée, on doit tout d’abord vérifier si elle
existe dans la liste ou non.
Pour supp_tete et supp_queue : voir cours
Procedure SupprimeSalle( L : *LD , NumS :entier)
Fonction SupprimeSalle (L : LD, NumS :entier) : LD
Var p : *cellule
Début
p <- chercherSalle (L , NumS) 
si (p = NULL) alors
écrire (‘’salle inexistante, pas de suppression’’)
sinon // faire la suppression
si (p =L.tete)
L<- Supp_tete(L)
Sinon
Si (p =L.queue) alors

8
 L <- Supp_queue(L)
Sinon
q->precedent ->suivant <- q ->suivant
q ->suivant ->precedent <- q <- precedent
liberer (q)
finsi
finsi
finsi
SupprimeSalle <- L
fin

7. Écrire la fonction ChercherSalleVide (L:LD): *cellule qui permet de

retrouver l’adresse de la première salle dont toutes les opérations sont
terminées.
Fonction ChercherSalleVide(L : LD) : *cellule
Var p : *celleule
Test : booleen
I , nb : entier
Début
Si (L.tete = L.queue=NULL) alors
Ecrire (‘’liste vide’’)
Sinon
P <- L.tete
Test <- faux
Nb <- 0
Tant que (p <> NULL et test = faux) faire
Pour i allant de 1 à p->val.nbop faire

9
 Si p->val.T_op[i].etat =0) alors
Nb <- nb+1
Finsi
Si (nb = p->val.nbop) alors
Test <- vrai
Finsi
Si (test = faux) alors
P <- p -> suiavnt
Finsi
ChercherSalleVide <- P
Fin

8. Écrire la procédure EmpilerSalle (L: *LD, P: *Pile) qui permet d’ajouter

dans la pile P toutes les salles dont toutes les opérations sont
terminées. L’insertion dans la pile doit se faire comme suit :
- chercher une salle dont toutes les opérations sont terminées en utilisant
la fonction ChercherSalleVide.
- ajouter cette salle à la Pile en utilisant la fonction prédéfinie
Empiler( P:Pile, S: Salle): Pile qui permet d’empiler une salle dans une
Pile.
- supprimer cette salle de la liste en utilisant la fonction SupprimerSalle.
- répéter ce traitement jusqu’à l’ajout dans la pile de toutes les salles dont
toutes les opérations sont terminées.

procédure EmpilerSalle (L: *LD, P: *Pile)

var p, q : *cellule
debut Fonction ChercherSalleVide(L : LD) : *cellule

Si (L.tete = L.queue=NULL) alors Fonction SupprimeSalle (L : LD, NumS :entier)

10
Ecrire (‘’liste vide’’)
Sinon
Tant que (ChercherSalleVide (*L)<> NULL) faire
Q<- ChercherSalleVide (*L)
*P <- Empiler (*P,Q->val) // voir cours pour empiler
Empiler (P, Q->val)
*L <- SupprimeSalle (*L, Q->val.NumS)
Fin TQ
Fin
Fonction empiler (P : Pile, S :salle) : Pile

Procedure empiler (P : *Pile, S : Salle)

11
Les fonctions
Fonction nom_f (paramètres = données necessaires au traitement : transmises
par valeur) : resultat
(return)
Les procédures (void) pas de return  (paramètres = données (transmises par
valeur)+ des résultats(transmis par adresse))

12