UNIVERSITE SIDI MOHAMMED BEN ABDELLAH

FACULTE des SCIENCES DHAR EL MEHRAZ de FES

Laboratoire d’Electronique, Signaux-Systèmes et Informatique
LESSI
Equipe AIMS

Travaux Pratiques :
Langage C
Licence Professionnelle TSEI :

Pr. Hassan Qjidaa

 TP1
1.1 Exercice 1

Ecrire un programme qui saisit 2 entiers et affiche successivement la somme , la

différence, le produit et le quotient de ces 2 entiers.

1.2 Exercice 2

Ecrire un programme qui demande à l’utilisateur de donner le rayon d’un cercle

et lui retourne sa surface et son périmètre.

1.3 Exercice 3

Ecrire un programme qui saisit deux entiers a et b et permute la valeur de ces

deux entiers.

1.4 Exercice 4

Ecrire un programme qui saisit un réel x et un entier n et affiche x à la puissance

n.

1.5 Exercice 5

Ecrire un programme retournant la factorielle d’un nombre entier entré par

l’utilisateur.

1.6 Exercice 6

Ecrire un programme qui résout les équations du second degré (ax2 + bx + c =

0).
Le programme demande a, b et c à l’utilisateur puis indique le nombre de
solutions ainsi que leurs valeurs.

1.7 Exercice 7

Ecrire un programme retournant le PGCD ainsi que le PPCM de 2 entiers entrés

par l’utilisateur.
 TP2
2.1 Exercice 1

Ecrire un programme qui initialise un tableau d’entiers de dimension N puis

calcule la moyenne des éléments du tableau.

2.2 Exercice 2

Ecrire un programme qui saisit un entier a et range dans un tableau d’entier les
valeurs de ai avec i = 0,N.

2.3 Exercice 3

Ecrire un programme qui initialise deux vecteurs appartenant à Rn et retourne la

norme de ces deux vecteurs ainsi que leur produit scalaire.

2.4 Exercice 4

Ecrire un programme qui, étant donnés deux tableaux A et B d’entiers de même

longueur N, détermine le nombre de positions où A[i] = B[i].

2.5 Exercice 5

On considère le tableau T de N réels. Ecrire un programme qui affiche le rang

dans le tableau d’un réel x donné, et ce dans les deux cas suivants:

 on est assuré que le réel x existe dans le tableau,

 il est possible que cet élément n’existe pas.

2.6 Exercice 6

Ecrire un programme qui trie de manière croissante un tableau d’entiers.

 TP3
3.1 Exercice 1

Ecrire un programme qui affiche le code ASCII de chaque lettre de votre

prénom.

3.2 Exercice 2

Ecrire un programme qui saisit successivement chaque caractère de votre

prénom puis les affiche.

3.3 Exercice 3

Ecrire un programme qui saisit un caractère alphabétique et indique si celui-ci

est une voyelle ou une consonne et s’il s’agit d’une majuscule ou non. Vous
utiliserez la table du code ASCII.

3.4 Exercice 4

Ecrire un programme qui lit successivement

 un nombre (nombre1)
 un opérateur (+,-,*,/)
 un nombre (nombre2)

et qui retourne le résultat de l’opération: nombre1 operateur nombre2, puis

propose d’arrêter ou de refaire le calcul.

3.5 Exercice 5

Parmi tous les entiers supérieurs à 1 et inférieurs à 500, il y en a seulement 4 qui

peuvent être représentés par la somme des cubes de leur chiffre (xyz = x3 + y3 +
z3).
Ecrire un programme qui détermine ces 4 nombres.

3.6 Exercice 6

La fonction rand retourne un entier compris entre 0 et RAND_MAX de manière

aléatoire. La constante RAND_MAX ainsi que le prototype de la fonction rand
sont définis dans le fichier stdio.h.
Ecrire un programme qui initialise de manière aléatoire un entier entre 0 et 100
et propose de le faire deviner à l’utilisateur. Pour ce faire, a chaque tentative de
l’utilisateur, le programme lui indique si sa proposition est plus petite ou plus
grande que la valeur de l’entier recherché.
 TP4
4.1 Exercice 1

Saisir une matrice d’entiers 2x2, calculer et afficher son déterminant.

Tableaux à plus de deux dimensions:

On procède de la même façon en ajoutant les éléments de dimensionnement ou

les indices nécessaires.

4.2 Exercice 2

Un tableau doit mémoriser les superficies de A chaque pièce d’un pâté de

maison homogène . Il y a 9 immeubles, 6 étages par immeuble, 3 appartements
par étage et 3 pièces par appartement.

Que donnerait la définition du tableau correspondant?

Combien de pièces comporte le pâté de maison?

La seconde pièce du premier appartement de l’étage supérieur de la septième

maison a une surface de 40 m2. A quoi ressemble l’affectation de cette valeur à
l’élément de tableau correspondant?

Il faut saisir les valeurs en m2 pour tous les appartements. Ecrire une boucle de
saisie.
 TP5

5.1 Exercice 1

Ecrire un programme qui, à partir de la saisie d’une date de naissance, affiche le

signe du zodiaque correspondant.
Capricorne : 22/12 au 20/1
Verseau : 21/1 au 19/2
Poissons : 20/2 au 20/3
Bélier : 21/3 au 20/4
Taureau : 21/4 au 20/5
Gémeaux : 21/5 au 21/6
Cancer : 22/6 au 22/7
Lion : 23/7 au 23/8
Vierge : 24/8 au 23/9
Balance : 24/9 au 23/10
Scorpion : 24/10 au 22/11
Sagittaire : 23/11 au 21/12

Utiliser la construction if ... else puis switch ... case

5.2 Exercice 2

Ecrire un programme qui affiche le menu suivant:

1. Conversion de degrés en radians

2. Conversion d’un temps décimal entré en heures sous la forme Heures +
Minutes + Secondes
3. Conversion d’un entier décimal en binaire
4. Fin du programme

puis réalise la conversion demandée par l’utilisateur et renvoie le menu.

5.3 Exercice 3

Il est fréquent que l’on munisse les matricules, les codes de nomenclature, les
numéros de compte, . . . , d’une clé de contrôle qui permet de vérifier leur
validité. Cette clé est calculée selon un certain procédé à partir des autres
chiffres. Elle est en général ajoutée à la fin du code. Une technique simple pour
produire une clé de contrôle consiste à multiplier chaque chiffre du code par un
certain facteur (i.e. une pondération), à faire la somme des chiffres des produits
obtenus, à diviser cette somme par 10 et à retrancher à 10 le reste de la division.
Cette différence donne la clé de contrôle.

Exemple:

matricule sans la clé : 123456

facteur de pondération: 131313
produit (chiffre * poids): 1 6 3 12 5 18
somme des chiffres (produits): 1 6 3 3 5 9
somme des sommes des chiffres: 27
total / 10 : 27 : 10 = 2
reste 7 clé: 10 - 7 = 3
matricule avec la clé : 1234563

a) Ecrire un programme qui munisse de clés de contrôle un certain nombre de

matricules devant être attribués.

b) Un programme qui vérifie la validité d’un matricule saisi à l’aide de la clé de

contrôle

Rappel: Pour la fonction a modulo b (le reste de la division de a par b

a%b

5.5 Exercice 5

Ecrire un programme qui calcule l’intégrale d’une fonction de type ax2 + bx + c

entre deux points x1 et x2 par la méthode des trapèzes.
Le programme devra demander à l’utilisateur les coefficients a,b et c ainsi que
les bornes x1 et x2 et le nombre d’intervalles de calcul. On calculera par la suite
la solution exacte puis l’erreur commise par la méthode des trapèzes.
 TP6
6.1 Exercice 1

Ecrire une fonction qui calcule et renvoie la valeur du polynôme P(X),

représenté par le tableau de ses coefficients, pour une valeur donnée de la
variable X.

6.2 Exercice 2

Ecrire une fonction qui calcule le produit C d’une matrice A ayant nla lignes et
nca colonnes par une matrice B ayant nlb lignes et ncb colonnes. Ces trois
matrices seront représentées par des tableaux de double déclarés avec N lignes et
N colonnes, N étant une constante suffisamment grande. On rappelle que le
produit Anla,nca Bnlb,ncb est une matrice Cnla,ncb définie par :

6.3 Exercice 3

1. Ecrire une fonction calculant Cnp à partir de n et p. Constatez que la

formule de base

est peu utilisable, car les expression n!, p! et (n - p)! provoquent

rapidement des débordements de capacité.

2. En remarquant que la formule précédente peut se mettre sous la forme

écrivez un programme plus réaliste pour le calcul de Cnp.

3. On peut calculer Cnp sans multiplications, grâce à la propriété Cnp = Cn - 1p -

1
+ Cn - 1p.

Ecrire un programme qui garnit un tableau rectangulaire - déclaré par

ailleurs - avec les valeurs des n premières lignes du "triangle de Pascal"
(voir ci-dessous), n étant fourni par l’utilisateur.
 1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
etc.

4. Le programme précédent nécessite une quantité de mémoire importante.

Comment peut-on en réduire l’encombrement presque de moitié?
5. 6.4 Exercice 4
6. Ecrire un programme qui lit un verbe régulier en "er" au clavier et qui en
affiche la conjugaison au présent de l’indicatif de ce verbe. Contrôlez s’il
s’agit bien d’un verbe en "er" avant de conjuguer. Utiliser les fonctions
gets, puts, strcat et strlen.
7. Exemple:

Verbe : trouver
je trouve
tu trouves
il trouve
nous trouvons
vous trouvez
ils trouvent

6.5 Exercice 5

La suite de Fibonacci est définie par la récurrence suivante :

Ecrire un programme calculant le nième terme de la suite. Ce programme fera

appelle à la fonction récursive fibo.

On peut montrer que :

Ecrire une fonction fibo2 calculant Fn par la méthode décrite ci-dessus et

recevant comme unique argument n. Cette fonction pourra faire appel à d’autres
fonctions de votre choix.
Par exemple une fonction retournant le vecteur (Fn Fn-1)T, cette fonction pourrait
faire appel à une fonction matmul retournant le produit de deux matrices entrées
en argument.

6.6 Exercice 6

Écrire une fonction fonc qui reçoit comme arguments une fonction f, un tableau
d’entiers ainsi que la taille du tableau. La fonction f prend deux entiers en
paramètres et retourne un entier. Si le tableau contient les valeurs x0,x1,x2,...,xn
la fonction fonc retourne la valeur:
f(f(... f(f(x0,x1),x2),...)xn)
Vous écrirez plusieurs fonctions f de telle sorte que la fonction fonc retourne le
maximum, la somme ou le produit des éléments du tableau?

6.7 Exercice 7

Écrire un programme comportant :

1. la déclaration de 3 variables globales entières heures, minutes, secondes ;

2. une fonction print_heure sans argument qui imprimera le message :

Il est ... heure(s) ... minute(s) ... seconde(s)

en respectant l’orthographe du singulier et du pluriel;

3. une fonction set_heure recevant comme arguments trois paramètres de

type entiers h, m et s, dont les valeurs seront affectées respectivement à
heures, minutes et secondes;
4. une fonction tick qui incrémentera l’heure de une seconde;
5. une fonction main qui appellera les fonctions print_heure, set_heure et
tick.

Vous commencerez par mettre toutes ces fonctions dans un même fichier. Vous
les placerez ensuite chacune dans des fichiers différents. Les variables globales
seront placées dans la fonction main.
 TP7
7.1 Exercice 1

Soit le programme :
int main(void)
{
int a;
int *pa;
int **ppa;

a = 1;
pa = &a;
ppa = &pa;

return(0);
}

Que valent les expressions suivantes &a, *pa, &pa, *ppa, **ppa , &ppa?
Parmi les expressions précédentes, lesquels désignent la même la valeur que
celle contenue dans a, pa et ppa?

7.2 Exercice 2

Comprenez et comparez les versions suivantes de la fonction strcpy(s, t) qui

copie une chaîne de caractères t dans une chaîne de caractères s.

1. Version utilisant des tableaux :

void strcpy(char* s, char* t) {

int i = 0;
while ((s[i] = t[i]) != ’\0’) i++;
}

2. Version utilisant des pointeurs :

void strcpy(char* s, char* t) {

while ((*s = *t) != ’\0’) {
++s;
t++;
}
}
 3. Version utilisant des pointeurs (2e version):

void strcpy(char* s, char* t) {

while ((*s++ = *t++) != ’\0’) ;
}

4. Version utilisant des pointeurs (3e version):

void strcpy(char* s, char* t) {

while (*s++ = *t++) ;
}

7.3 Exercice 3

Écrivez un programme qui utilise la fonction compare(a, b) qui compare les

chaîne de caractères a et b. La fonction retourne une valeur négative, nulle ou
positive selon que a est lexicographiquement inférieure, égale ou supérieure à b.
Écrivez deux versions de ce programme. La première avec des tableaux, la
seconde avec des pointeurs.

7.4 Exercice 4

Écrivez un programme qui utilise la fonction int toInt(char* s) qui convertit la

chaîne de caractères ascii s en un entier. On considère que s représente un
nombre entier positif. Utilisez des pointeurs pour implémenter cette fonction.

7.5 Exercice 5

Le programme suivant trie de manière croissante un tableau d’entier:

#include<stdio.h>
#define dim 10

int main ()
{
int tab[dim] = { 6,7,8,9,1,0,3,2,5,4 };
int i,j,tmp;

for(i=0;i<dim-1;i++)
for (j=i;j<dim;j++)
if (tab[i]>tab[j]) {
tmp=tab[i];
tab[i]=tab[j];
tab[j]=tmp;
 }

return (0);
}

Réécrire ce programme en utilisant, dans le corps de la boucle de tri, un pointeur

p pointant sur le premier élément du tableau tab, au lieu de tab[x]. Le
programme devra contenir la déclaration ainsi que l’instruction suivantes:

int *p;
p=tab;

7.6 Exercice 6

Écrire un programme qui lit un entier X et un tableau A du type int au clavier et

élimine toutes les occurrences de X dans A en tassant les éléments restants. Le
programme utilisera les pointeurs P1 et P2 pour parcourir le tableau.

7.7 Exercice 7

Écrire un programme qui range les éléments d’un tableau A du type int dans
l’ordre inverse. Le programme utilisera des pointeurs P1 et P2 et une variable
numérique AIDE pour la permutation des éléments.

7.8 Exercice 8

Soit le programme contenant les déclarations suivantes:

char *tab[]={
"Miles Davis",
"Thelonious Monk",
"Charles Mingus",
"Duke Ellington", };
char **p=tab;

Déterminer la valeur des 2 séries suivantes:

1) (*p++)[1] 1) (*p++)[1]
2) *p++[1] 2) *p[1]++
3) (*++p)[4] 3) (*++p)[4]
4) *++*p 4) *++*p
 TP8
8.1 Fonctions Utiles

Voici la fonction aleat de tirage aléatoire d’un nombre entre 0 et n :

int aleat(int n)
{
int i;
i = rand() / (RAND_MAX + 1. ) * (n+1) ;
return(i);
}

La fonction rand fournit toujours la même suite de valeurs , d’une execution à

l’autre. (Voir définition de rand et srand dans les annexes) . Pour utiliser rand, il
faut

#include <stdlib.h>

Pour obtenir une suite de nombres aléatoires différente à chaque execution ,

voici la fonction aleatvar:

int aleatvar(int n)
{
int i;
static int prem = 1 ; /* valeur prise au premier appel a aleatvar */
time_t date ; /* time_t est un type entier defini dans time.h */
/* ----------------------------------------------*/
/* Modification de la "graine" pour une
nouvelle sequence de nombres aleatoires */
/* ----------------------------------------------*/
if{prem}
{
srand(time(&date));
prem = 0 ;
}
/* ----------------------------------------------*/
/* generation du nombre aleatoire */
/* ----------------------------------------------*/
i = rand() / (RAND_MAX + 1. ) * (n+1) ;
return(i);
}
Pour utiliser rand, srand, et time , il faut

#include <stdlib.h>
#include <time.h>

8.2 Le temps en C

Le fichier d’entête time.h propose au programmeur plusieurs méthodes

permettant la gestion du temps. Il existe deux moyens de manipuler le temps en
C:

 * La manipulation de la date et / ou de l’heure classique

 * La détermination du temps d’utilisation du processeur lors de
l’exécution d’un programme

Quelques fonctions:

 time: La routine time a pour prototype :

time_t time(time_t *ptr);

 Le type time_t est en fait un typedef pour unsigned long défini ainsi dans
time.h :

#ifndef _TIME_T_DEFINED
typedef long time_t; /* time value */
#define _TIME_T_DEFINED /* avoid multiple def’s of time_t */
#endif

 En fait la fonction time retourne le temps passé depuis le 1er janvier 1970
en secondes (norme POSIX). Elle retourne -1 en cas d’échec. Si ptr n’est
pas égal à null alors la valeur retournée par la fonction est aussi affectée à
*ptr.
 ctime: La fonction ctime est très similaire dans son fonctionnement. Elle a
pour prototype :

char *ctime(const time_t *ptr);

 La routine ctime retourne sous la forme d’une chaîne de caractères la date

d’une manière formatée et plus explicite par exemple :
 Sat Dec 15 12 : 02 : 41 2001
 Ce qui est plus lisible que :
 36578367
 Exemple::

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main( void )

{
//valeur qui va contenir le temps en secondes
//{\’e}coul{\’e} depuis le 01/01/1970
time_t time_of_day;

//on cherche le temps {\’e}coul{\’e}

time_of_day = time( NULL );

//on affiche ce temps d’une mani{\‘e}re explicite sous la forme

//d’une string gr{\a}ce {\‘a} ctime
printf( "Nous sommes le : %s", ctime( &time_of_day ) );
return 0;
}

 Temps utilisé par le processeur:

C’est la fonction clock_t qui va nous permettre de traiter ce genre de cas.
Celle-ci a pour prototype :

clock_t clock(void);

 Tout comme time_t, clock_t est un autre nom pour unsigned long :
 La routine clock renvoie le temps utilisé par le préprocesseur en
microsecondes.
 Ainsi en faisant deux appels à clock, l’un au départ d’un programme, et
l’autre à la fin, on obtient par différence le temps utilisé par le
programme.

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
/**
* fonction contenant des boucles
* inutiles faisant un traitement
* inutile permettant de perdre du temps
*/
void compute( void )
{
int i, j;
double x;

x = 0.0;
//boucles inutiles
for( i = 1; i <= 10000; i++ ) {
for( j = 1; j <= 10000; j++ ) {
x += i + j ;
}
}

printf( "%16.7f\n", x );
}

int main( void )

{
//temps au d{\’e}part et {\‘a} la fin
clock_t start_time, end_time;

//recuperer la date au d{\’e}part

start_time = clock();

//faire un traitement
compute();

//recuperer le temps {\‘a} la fin

end_time = clock();

//afficher la difference
printf( "Le temps d’execution est de %lu secondes\n",
(long) ((end_time - start_time) / CLOCKS_PER_SEC) );

return 0;
}
  Le programme ci-dessus donne la sortie :

Lord Asriel : gcc temps.c -o temps

Lord Asriel : temps
1000100000000.0000000
Le temps d’execution est de 2 secondes
Lord Asriel :

8.3 Exercice 1. : Jeu du devin

A l’aide d’une des fonctions aléatoires, écrire un programme qui choisit un

nombre entier au hasard entre 0 et 1000 et qui demande à l’utilisateur de le
deviner. A chaque proposition faite par le joueur, le programme répondra en
situant le nombre proposé par rapport à celui à deviner (plus grand, plus petit,
GAGNE).

Lorsque le joueur aura deviné le nombre choisi, ou lorsque qu’un nombre

maximal de coups (10) aura été dépassé, le programme affichera la
récapitulation des différentes propositions.

8.4 Exercice 2 : Mastermind

Réaliser un programme qui choisit au hasard une combinaison de 5 chiffres

(compris entre 1 et 8) et qui demande à l’utilisateur de la deviner. A chaque
proposition, le programme donnera

 Le nombre de chiffres exacts à la bonne place

 Le nombre de chiffres exacts à la mauvaise place

Les différentes propositions du joueur seront fournies sous la forme de 5 chiffres

consécutifs (sans aucun séparateur), validés par return. Le programme devra
pouvoir traiter le cas de réponses incorrectes (chiffre trop grand, lettre au lieu de
nombre).

Prévoir un nombre limite d’essais au bout duquel le programme renverra la

solution.
 TP9
9.1 Exercice 1

1. Donner les déclarations des structures suivantes :

a. date : numéro du jour, nom du mois, année;
b. point : coordonnées (entières) d’un point;
c. rect : coordonnées d’un rectangle (côtés horizontaux);
d. segment : segment entre deux points.
2. Écrire le corps d’une fonction AfficheDate affichant la date passée en
paramètre.

Prototype : void AfficheDate( date *dp );

3. Écrire une fonction DemandeDate demandant une date au clavier et

remplissant les champs de la structure passée.

Prototype : void DemandeDate( date *dp );

4. Écrire une fonction NumeroMois retournant l’entier compris entre 1 et 12

correspondant au numero du mois dont le nom est passé. Si le mois
n’existe pas, NumeroMois doit retourner -1.

Prototype : int NumeroMois( char *nommois ); A l’aide de cette fonction,

améliorer la fonction DemandeDate afin qu’elle vérifie que la date entrée
est correcte.

5. Écrire une fonction CompareDates prenant deux dates d1 et d2 et

retournant -1 si d1 est avant d2, 1 si d1 est après d2, ou 0 si les deux dates
sont égales.

Prototype : int CompareDates( date *d1, date *d2 );

9.2 Exercice 2

1. Écrire une fonction

int EnregistreDates( date d[], int N, char *nomfichier );

qui sauvegarde un tableau d de N dates dans un nouveau fichier texte. La

fonction retournera 1 en cas de succès, 0 en cas d’échec (erreur).

Chaque ligne du fichier texte contiendra une date: jour, mois, année.

2. Écrire une fonction

 int LireDates( date d[], char *nomfichier );

qui relise dans le tableau d les dates sauvegardées dans le fichier spécifié
par nomfichier par EnregistreDates. LireDates retournera le nombre de
dates lues.

9.3 Exercice 3

L’algorithme de tri par sélection permet de trier les éléments d’un tableau par
ordre croissant (ou décroissant). Il peut être décrit comme suit, pour un tableau
T de N éléments :

Pour i = 0 à N-1 faire

chercher l’élément le plus petit dans l’intervalle i, ..., N et l’échanger avec

l’élément T[i].

1. Dérouler à la main l’algorithme sur l’exemple suivant : 1, 9, 2, 1, 7 .

2. Écrire une fonction TriEntiers triant un tableau de N entiers.

Prototype : void TriEntiers( int T[], int N );

3. Écrire une fonction TriDates triant un tableau de N dates (définies comme

dans l’exercice 1), en utilisant la fonction CompareDates

Prototype : void TriDates( date T[], int N );

 TP10

10.1 Exercice 1

 Ecrire une structure matrice pleine contenant ses dimensions, et un

tableau de pointeurs.
 Ecrire une structure matrice skyline contenant ses dimensions, un pointeur
sur un tableau donnant pour chaque ligne i de la matrice l’indice du
premier élément non-nul, et le dernier élément non-nul, et un pointeur sur
le tableau des coefficients de la matrice .
 Ecrire une structure vecteur contenant les dimensions du vecteur
V(Nelements, Nombre-de-vecteurs) et une union tableau pouvant être un
tableau d’entiers, de floats ou de doubles.

10.2 Exercice 2

 Ecrire 2 fonctions pour créer et détruire une matrice (allouer la place,

désallouer)
 Ecrire 2 fonctions pour sommer 2 matrices pleines ou skylines
 Ecrire 2 fonctions produit matrice vecteurs pour les 2 structures matrices ,
et la structure vecteur définie plus haut. Définir un test pour déterminer si
l’on a affaire a un tableau d’entiers, de floats ou de doubles.

10.3 Exercice 3

Arbre binaire.

Il s’agit de représenter des données structurées sous forme d’arbre binaire.

Chaque noeud de l’arbre contient une information (ici pour simplifier un entier)
et des pointeurs sur ses deux "fils" droit et gauche.
 Écrire la structure C correspondant à un noeud de l’arbre: NOEUD.
L’information contenue dans chaque noeud sera représentée ici,
simplement par un entier.
 Dans un arbre le noeud "du haut" est appelé racine c’est le point d’entrée.
Les noeuds "du bas" sont appelés feuilles, leurs pointeurs fils ont la valeur
NULL.
 Déclarer un pointeur racine sur un NOEUD et construire (attention aux
allocations mémoire) à partir de ce cette racine l’arbre suivant:

 On cherche maintenant à parcourir cet arbre selon une fonction dite

"profondeur d’abord", illustrée sur le diagramme ci-dessous:

 Écrire la fonction (récursive) de parcours de l’arbre qui imprime

l’information contenu dans les noeuds. On doit donc obtenir: 0 1 2 3 4 5
6.
 Écrire enfin, sur le même modèle, une fonction qui détruit un arbre en
prenant comme argument un pointeur sur sa racine. Le fichier data_01.h
 C’est le fichier à inclure pour les applications qui utiliseront ces arbres. Il
contient les définitions de type et les prototypes des fonctions.

Notons que la structure noeud contient des pointeurs sur des variables de type
struct noeud: la construction est "récursive". Le fichier data_01.c Il contient le
corps des fonctions. Il utilise bien sûr data_01.h .

Ce fichier peut être compilé pour créer un module objet:

==> gcc -c data_01.c

L’application: data_01_main.c Il faut inclure data_01.h on peut ensuite utiliser

les types et les fonctions.

Pour compiler et exécuter il ne faut pas oublier le module objet data_01.o

==> gcc -o data_01_main data_01_main.c data_01.o

10.4 Exercice 4

Liste chaînée.

La liste chaînée est une structure très pratique pour stocker et parcourir des
données. Elle est constituée d’une tête et d’éléments.

La tête de liste contient une information spécifique (un nom par exemple) et un
pointeur sur le premier élément de la liste. Chaque élément contient une
information (ici un entier pour simplifier) et un pointeur sur l’élément suivant.
Le pointeur sur le suivant du dernier élément vaut null.
 écrire la structure C correspondant à la tête de liste: TETE. On y mettra
aussi une information, par exemple: un nom (chaîne de caractères).
 écrire la structure C correspondant à un élément: ELEMENT.
L’information contenue dans chaque élément sera représentée, ici,
simplement par un entier. On supposera, pour simplifier la
programmation, que ces entiers sont tous différents.
 écrire une fonction ajouter qui insère dans une liste un élément contenant
l’information i de telle sorte que la liste soit triée par construction dans
l’ordre des entiers croissants.
 écrire une fonction qui parcourt la liste en écrivant l’information contenue
dans chaque élément.
 écrire une fonction supprimer qui élimine de la liste un élément contenant
l’information de valeur i (si il en existe un).
 déclarer et allouer une tête de liste, ajouter des éléments, l’écrire, en
supprimer, l’écrire encore.

Remarque:
  on veillera à faire fonctionner les fonctions ajouter et supprimer dans tous
les cas de figure: en début de liste, en milieu de liste et en fin de liste.

Le fichier data_02.h C’est le fichier à inclure pour les applications qui utiliseront
des listes chaînées. Il contient les définitions de type et les prototypes des
fonctions.

Notons que les structures ELEMENT et TETE contiennent des pointeurs sur des
variables de type struct element (pas toujours défini).

Le fichier data_02.c Il contient le corps des fonctions ajouter, supprimer,

parcours. Il utilise bien sûr data_02.h.

Ce fichier peut être compilé pour créer un module objet :

==> gcc -c data_02.c

L’application: data_02_main.c Il faut inclure data_02.h on peut ensuite utiliser

les types et les fonctions.

==> gcc -o data2 data_02_main.c data_02.o