Université d’Aix-Marseille - Faculté des Sciences

Licence d’Informatique - Licence de Mathématiques

ENSIN2U1 - Programmation

TD no 6

Structures, Piles et Files tabulaires

1. Manipulation de structures simples

On reprend ici le type POINT introduit en cours :
typedef struct { f l o a t x , y ; } POINT ;

1.1. Définir la fonction distance qui prend 2 points en paramètres et renvoie un réel qui est la distance
entre ces 2 points (on utilisera la fonction prédéfinie sqrt(x) calculant la racine carrrée de x).
Tester cette fonction dans un programme qui saisit les coordonnées des 2 points et affiche la distance
calculée.

1.2. Définir la fonction perimetre_triangle qui prend 3 points en paramètres et retourne la longueur
du périmètre du triangle défini par ces 3 points.

1.3. Définir la fonction milieu qui prend 2 points en paramètres et retourne le point milieu des deux
points en paramètres.

1.4. Transformer la fonction précédente pour en faire une procédure qui prend en arguments 3 points
p1, p2, et pm, et qui affecte pm de telle sorte que pm soit le point milieu des points p1 et p2.

2. Manipulation de structures imbriquées

On reprend ici le type POINT introduit en cours :
typedef struct { f l o a t x , y ; } POINT ;

2.1. Donner une structure de données CERCLE, permettant de définir un cercle par la donnée de son
centre (un point) et de son rayon.

2.2. Définir une fonction qui calcule le périmètre d’un cercle.

2.3. Définir une fonction qui prend en paramètres un point p et un cercle c et qui retourne 1 si le point
p est à l’intérieur du cercle c et 0 s’il est à l’extérieur.

2.4. Ecrire un programme qui saisit les informations relatives à un cercle et à un point et utilise les
fonctions précédentes.

3. Primitives de gestion de piles

Dans ce problème, on s’intéresse à la gestion d’une pile quand celle-ci est représentée sous forme de table.
Le type C est celui donné en cours :
#define MAX . . .
typedef ? ELEMENT; /∗ pour d é f i n i r l e t y p e d e s é l é m e n t s dans l a p i l e ∗/
typedef struct
{
int sommet ; /∗ i n d i c e du sommet de p i l e : de −1 à MAX −1 ∗/
ELEMENT tab [MAX] ; /∗ t a b l e a u c o n t e n a n t l e s é l é m e n t s ∗/
} PILE_TAB ;
Programmez les primitives spécifiées ci-dessous :
int p i l e _ v i d e (PILE_TAB p )
/∗ s p é c i f i c a t i o n s : é v a l u é e à 1 s i l a p i l e e s t v i d e e t à 0 s i n o n ∗/

int p i l e _ s a t u r e e (PILE_TAB p )
/∗ s p é c i f i c a t i o n s : é v a l u é e à 1 s i l a p i l e e s t s a t u r é e e t à 0 s i n o n ∗/

void i n i t _ p i l e (PILE_TAB ∗p )
/∗ s p é c i f i c a t i o n s : i n i t i a l i s e à v i d e l a p i l e p o i n t é e par p ∗/

void e m p i l e (PILE_TAB ∗p , ELEMENT e )

/∗ s p é c i f i c a t i o n s : a j o u t e l ’ é l é m e n t e dans l a p i l e p o i n t é e par p ∗/
/∗ s o u s r é s e r v e que l a p i l e ne s o i t pas s a t u r é e ∗/

void d e p i l e (PILE_TAB ∗p , ELEMENT ∗ e )

/∗ s p é c i f i c a t i o n s : e n l è v e l e sommet de l a p i l e p o i n t é e par p : é l é m e n t ∗/
/∗ d ’ a d r e s s e e s o u s r é s e r v e que l a p i l e ne s o i t pas v i d e ∗/
Réfléchissez aux traitements éventuellement nécessaires pour les cas limites pour empile (saturation) et
depile (pile vide).

4. Exploitation d’une pile

Dans ce problème, nous allons programmer la procédure Hanoi en simulant la récursivité à l’aide d’une
pile. Dans une première partie, il vous faut définir le type ELEMENT adéquat, puis ensuite écrire la
procédure qui réalisera le traitement que faisait Hanoi dans la version vue en cours et rappelée ci-dessous :
void h a n o i ( int n , char x , char y , char z )
/∗ s p é c i f i c a t i o n s e x t e r n e s : a f f i c h e l e s a c t i o n s à r é a l i s e r ∗/
/∗ pour d é p l a c e r n d i s q u e s de x v e r s z a v e c l e p i e u annexe y ∗/
{
if ( n > 0 ) {
h a n o i ( n−1,x , z , y ) ;
p r i n t f ( " d e p l a c e r %c v e r s %c " , x , z ) ;
h a n o i ( n−1,y , x , z ) ;
}
}

5. Primitives de gestion de files

Dans ce problème, on s’intéresse à la gestion d’une file quand celle-ci est représentée sous forme de table.
Le type C est celui donné en cours :
#define MAX . . .
typedef . . . ELEMENT; /∗ pour d é f i n i r l e t y p e d e s é l é m e n t s dans l a p i l e ∗/
typedef struct
{
int debut , f i n ; /∗ i n d i c e de d e b u t e t de f i n de l a f i l e ∗/
int l o n g u e u r ; /∗ l o n g u e u r de l a f i l e ∗/
ELEMENT tab [MAX] ; /∗ t a b l e a u c o n t e n a n t l e s é l é m e n t s ∗/
} FILE_TAB ;
Programmez les primitives rappelées ci-dessous :
– test de vacuité (est-ce que la file est vide)
– test de saturation (est-ce que la file peut encore recevoir un élément)
– successeur (qui fournit, étant donné un indice de début ou de fin, l’indice suivant)
– initialisation d’une file à vide
– ajouter (on dit parfois "enfiler")
– supprimer (on dit parfois "défiler")