1

SOMMAIRE
SOMMAIRE……………………………………………………………………………………………………………..……..02

TP1 (tableaux et temps d’exécution)……………………………………………………………………………..03

Recherche du maximum…………………………………………………………………………………………….03
Tri à bulles ………………………………………………………………………………………………………………….04
Recherche dichotomique……………………………………………………………………………………………05

TP2( tableaux et temps d’exécution (suite))……………………………………………….………….………07

Inversion d’une chaîne en la répétant n fois …………………………………………………….……….07
Calcul d’une suite un………………………………………………………………………………….……………….08
Création des fonctions ………………………………………………………………………………….……………08
Chercher l’erreur………………………………………………………………………………….…………………….15

TP3 (Listes chaînées)……………………………………………………………………………………….…….………16

TP4( Liste de personnes)…………….………………………………………………………………………..………25

TP5(Polynômes)……………………………………………………………………………………………………………30

TP6( Piles - Files)……………………………………………………………………………………………………………36

TP7( Arbres)………………………………………………………………………………………………….………………41

TP8( Graphes)…………………………………………………………………………………………………….…………50

2
 TP1 Tableaux et temps d’exécution

Exercice1: Recherche du maximum

1.Ecrivez un programme en C qui implémente un aglorithme de recherche du maximum dans un
ensemble de n entiers. Testez-le avec n=5, puis avec n=900 000 000(dans le cas où n est très grand,
vous pouvez remplir le tableau en utilisant de la fonction rand()) .
2.Quel est le nombre de comparaisons effectués dans votre algorithme en termes de n ?
3.Est ce que votre algorithme est optimal ?

REPONSE
1. //On doit utiliser un pointeur car, à partir d’un certain n , le tableau ne peut plus recevoir
d’éléments. On est donc arrivé à sa capacité maximale.

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

main()
{ printf("\n\n-----RECHERCHE DU MAXIMUM-----\n");
printf("________________________________________\n\n");
int n,i=0,*p,max;
printf("Veuillez entrer le nombre n de vos entiers: \n");
scanf("%d",&n);
srand(time(NULL));
p=(int*)malloc(n*sizeof(int));
//remplissage du tableau aléatoirement
while (i<n)
{
*(p+i)=rand();

i++;}
//Recherche du maximum
max=*p;
for (i=1;i<n;i++)
{
if (*(p+i)>max)
{
max=*(p+i);
}
}
//Affichage du maximum
printf(" \n \n Le maximum est : \n %d",max);
}

3
 2-En nombre de comparaisons, la complexité de l’algorithme est de : n-1
3- Supposons qu’on effectue n-2 itérations, il se peut que la solution soit à l’itération n-1 donc
elle ne sera pas atteinte n, donc l’algorithme dans ce cas sera incorrect .
Donc on peut conclure que notre algorithme est optimal.

Exercice 2 : Tri à bulles

Le tri à bulles s’effectue en n-1 étapes (pour un tableau de n éléments). A la i ème étape on balaye le
tableau en partant de la fin jusqu’à la case i et à chaque fois que l’élément courant est plus petit que son
prédécesseur, on échange leur position. Cette méthode a pour effet de faire remonter au fur et à mesure
les bulles les plus légères vers la surface.
Dans cet exercice, on va implémenter le tri à bulles en langage C , calculer et le afficher el nombre de
comparaison effectués par ce dernier et enfin comparer le résultat obtenu avec celui du cours.

REPONSE
1-Implémentation de l’algorithme du tri à bulles

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

main()
{ printf("\n\n-----TRI A BULLES-----\n");
printf("________________________________________\n\n");
int n,i,dim,aide,*p,en_desordre=1;
printf("Veuillez entrer la dimension de votre tableau : \n");
scanf("%d",&n);
p=(int*)malloc(n*sizeof(int));
//remplissage aléatoire du tableau
srand(time(NULL));
while (i<n)
{
*(p+i)=rand();

i++;}
//affichage du tableau initial
printf("\n \n Affichage du tableau rempli arbitrairement:\n\n");
for(i=0;i<n;i++){
printf("%d \t",*(p+i));}
dim=n;
while(en_desordre){
en_desordre=0;
for(i=0;i<dim-1;i++){
if(*(p+i)>*(p+i+1)){

4
 //Permutation
aide=*(p+i+1);
*(p+i+1)=*(p+i);
*(p+i)=aide;
en_desordre=1;
}
}
dim--;//ce n'est pas la peine d'aller jusqu'à la fin du tableau }
//affichage du tableau trié
printf("\n \n \nAffichage du tableau après le tri à bulles:\n \n");
for(i=0;i<n;i++){
printf("%d \t",*(p+i));}
}

2-Le nombre de comparaisons effectuées par cet algorithme est : n²

3-Le résultat obtenu est similaire à celui du cours !!

Exercice3 : Recherche dichotomique

On considère le tableau suivant A de 10 éléments :
1 7 8 9 12 15 18 22 30 31
Notre tâche est d’implémenter un algorithme qui va chercher la position de la clé=30.
Ca c’est d’une part, d’autre part , on suppose que le tableau A[1…n] contient n=2^k éléments (où k est
un entier positif).
Question : Combien d’itérations l’algorithme effectuera-t-il au maximum ? En déduire la complexité
(en O) de l’algorithme.
REPONSE
1- Implémentation et test de l’algorithme :
(le programme retourne l’emplacement de la clé 30, qui est 8 . Tel que l’indice de la
1 ere valeur est 0)
#include <stdio.h>
#include <stdlib.h>

int Recherche_Dichotomie(int A[],int n, int cle)

{
int milieu, d,f,trouve;
d=0;
f=n-1;
trouve=0;
do
{
milieu=((d+f)/2);
if (A[milieu]==cle){
trouve=1;}
else if (A[milieu]<cle){
d=milieu+1;}

5
 else{

f=milieu-1;}
}while(trouve==0);
return milieu;
}
//menu principal
int main()
{
printf("\n\n-----RECHERCHE DICHOTOMIQUE-----\n");
printf("________________________________________\n\n");
int A[10]={1,7,8,9,12,15,18,22,30,31};
printf("La cle 30 se trouve à la position %d du tableau
!",Recherche_Dichotomie(A,10,30));

2-Soit un tableau de n éléments tel que n=2K. Supposons que la clé ne sera trouvée qu’à la
dernière itération. On sait qu’à chaque itération, le tableau est divisé par deux. La position i
doit donc être multiplié par deux à chaque division effectué. Vu que le tableau est constitué
de n=2k éléments. Il y aura k division. D’où le nombre d’itérations maximal sera de k.
2-Dans un tableau de n éléments, on a 2k-1≤n≤2k. On néglige les autres instructions devant
la boucle Do While. La complexité est donc k-1≤log2(n) ≤k.
D’où La complexité est d’ordre log2(n).

6
 TP2 Tableaux et temps d’exécution(suite)

Exercice 1 : Inversion d’une chaîne de caractères en répétant chaque lettre n fois

Implémenter une fonction : char* multichar(char*s, int ) ;
Qui prend en argument une chaîne de caractères et renvoie une deuxième chaîne où l’ordre des lettres
est inversé et chaque lettre est répétée n fois.
Par exemple, si la fonction reçoit « ENSA » et 3 en arguments, elle renverra « AAASSSNNNEEE »
REPONSE

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

char *multichar (char *s, int n)

{
int i,j,l=strlen(s);
char *ns;
ns=(char*)malloc(n*l*sizeof(char)+1);//la nouvelle chaine
for(i=0;i<l;i++)
{
for(j=0;j<n;j++)
{
ns[n*i+j]=s[l-1-i];}}
ns[n*(l)]='\0'; // fermeture de notre chaine de caracteres
return(ns);}

main()
{
char *s; int n;
s=(char*)malloc(sizeof(s));
printf("\n\n-----Inverse d'une chaine en repetant chacune de ses lettres-----\n");
printf("________________________________________\n\n");
printf("Veuillez entrer un mot: \t");
scanf("%s",s);
printf("\n Veuillez saisir le nombre de repetition: \t");
scanf("%d",&n);
printf(" \n Le nouveau mot est : \n %s",multichar(s,n));
}

7
 Exercice 2 : Calcul d’une suite un
Soit la suite un définie par : u0=1 et un+1=3un2+2un+1
1-Ecrire une fonction qui prend en paramètre un entier n et qui retourne un tableau contenant les n
premiers termes de la suite un. La fonction doit marcher quel que soit l’entier n rentré.
2-Ecrire le programme principal qui saisit l’entier n et affiche les n premiers termes de la suite un (en
utilisant la fonction définie en 1).

REPONSE

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

void suite(int n)
{
int i;
unsigned long long int *p;
//remplissage du tableau avec de très longs carctères non signés
p=(unsigned long long int*)malloc(n*sizeof(unsigned long long int));
p[0]=1 ;// equivalente à u(0)=1

printf("p[0]=%d \n",p[0]);
for (i=0;i<n;i++)
{p[i+1]=3*p[i]*p[i]+2*p[i]+1;
//affichage au fur et a mesure
printf("p[%d]=%llu \n",i+1,p[i+1]);
}
}
main()
{
int n;
printf("\n\n-----SUITE Un-----\n");
printf("________________________________________\n\n");
printf("Entrez la valeur n: \t");
scanf("%d",&n);
suite(n); }

Exercice 3 : Création des fonctions pour chaque ligne ci-dessous

1. Supprimer un élément de la position i d’un tableau ;
2. Inverser le contenu d’un tableau
3. Fusionner deux tableaux triés de taille différente. Le tableau obtenu doit être également trié ;
4. Créer une matrice avec des valeurs aléatoires ;
5. Afficher le contenu de la matrice ;
6. Additionner deux matrices m1 et m2 ;
7. Multiplier deux matrices m1 et m2 ;

8
 REPONSE
______________________________________________________________________________

___________________________________ 1________________________________________
void suppr ()
{
printf("\n\n----Supprimer un élement de la position i d'un tableau-----\n");
printf("________________________________________\n\n");
int n ,i,b;
printf("Veuillez entrer la taille de votre tableau: \t");
scanf("%d",&n);
int *p;
p=(int*)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{
printf("Entrez p[%d]\t",i);
scanf("%d",p+i);}

printf("Veuillez entrer la position i que vous voulez supprimer sa valeur:

\t");scanf("%d",&b);

for (i=b;i<n;i++)
{
p[i]=p[i+1];
}
n=n-1; //puisqu'on supprimera un élément donc la dimension du nouveau tableau sera n-1
printf("\n Le nouveau tableau est: \n");
for(i=0;i<n;i++)
{
printf("p[%d]=%d \t \n",i,p[i]);}
}

_________________________________________________________________________

___________________________________ 2______________________________________
void inverse ()
{
printf("\n\n----Inverser le contenu d'un tableau-----\n");
printf("________________________________________\n\n");
int n , i,b,aide;
printf("Veuillez entrer la taille de votre tableau: \t");
scanf("%d",&n);

9
 int *p;
p=(int*)malloc(n*sizeof(int));
//remplissage du tableau
for(i=0;i<n;i++)
{
printf("Entrez p[%d] \t",i);
scanf("%d",p+i);}

printf("\n\n");
//permuation
for (i=0;i<n/2;i++)
{
aide=p[i];
p[i]=p[n-1-i];
p[n-1-i]=aide;}
//affichage du tableau obtenu
printf("le nouveau tableau est: \n");
for(i=0;i<n;i++)
{
printf("p[%d]=%d \n",i,p[i]);}
}

______________________________________________________________________________

____________________________________ 3________________________________________
void tri(int dim,int *p){

int en_desordre=1,i,aide;
while(en_desordre){
en_desordre=0;
for(i=0;i<dim-1;i++){
if(*(p+i)>*(p+i+1)){
//permutation
aide=*(p+i+1);
*(p+i+1)=*(p+i);
*(p+i)=aide;
en_desordre=1;
}
}
dim--;//ce n'est pas la peine d'aller jusqu'à la fin du tableau

}}
void fusion(){
printf("\n\n----Fusion de deux tableaux triés-----\n");
printf("________________________________________\n\n");

10
 int n1,n2,dim1,dim2,i,dim3,en_desordre,aide;

//création et remplissage du tableau M1

printf("Veuillez entrer la taille du tableau M1: \t");
scanf("%d",&n1);
int *p1;
p1=(int*)malloc(n1*sizeof(int));
for(i=0;i<n1;i++)
{
printf("Entrez M1[%d]\t",i);
scanf("%d",p1+i);}
//tri du tableau M1 (utilisation du tri à bulles du premier td)
tri(n1,p1);

//création et remplissage du tableau M1

printf(" \n \n Veuillez entrer la taille du tableau M2: \t");
scanf("%d",&n2);
int *p2;
p2=(int*)malloc(n2*sizeof(int));
for(i=0;i<n2;i++)
{
printf("Entrez M2[%d]\t",i);
scanf("%d",p2+i);}
//tri du tableau M2 (utilisation du tri à bulles du premier td)
tri(n2,p2);

//fusion des deux tableau

int *p3;
p3=(int*)malloc((n2+n1)*sizeof(int));
//remplissage du tableau p3 par les deux tableau p1 et p2
for(i=0;i<n1;i++){
*(p3+i)=*(p1+i);}
for(i=0;i<n2;i++){
*(p3+i+n1)=*(p2+i);}
//tri du tableau p3
tri(n2+n1,p3);

//affichage du tableau p3
printf("\n \n Le tableau trié obtenu de cette fusion est le suivant: \n");
for(i=0;i<n1+n2;i++){
printf("M3[%d]= %d \n",i,*(p3+i));}
}

11
 ______________________________________________________________________________

____________________________________ 4________________________________________
void creermat(){
printf("\n\n-----Création d'une matrice avec des valeurs aléatoires-----\n");

printf("________________________________________________________________\n\n");
srand(time(NULL));
int **matrice,i,j,n,m;
printf("La matrice est d'ordre nxm. Entrez leurs valeurs: \n n=\t");
scanf("%d",&n);
printf("\t m= \t");
scanf("%d",&m);

matrice=(int**)malloc(n*sizeof(int));
for(i=0;i<n;i++){
matrice[i]=(int*)malloc(m*sizeof(matrice[i]));}

for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
matrice[i][j]=rand();
}
}
______________________________________________________________________________

____________________________________ 5________________________________________
void affichermat(matrice,n,m){
printf("\n\n-----Affichage de la matrice-----\n");
printf("____________________________________\n\n");
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
printf("\n matrice[%d][%d]= %d",i,j,matrice[i][j]);
}
}
}

12
 ______________________________________________________________________________

____________________________________ 6________________________________________
void AddMat (){
int n1,n2,m1,m2,i,j;
printf("\n\n-----Additionner deux matrices M1 et M2-----\n");

printf("________________________________________________________________\n\n");
srand(time(NULL));
int **matrice1,**matrice2;
//creation de la matrice 1 et la remplir aleatoirement
printf("La matrice 1 est d'ordre n1xm1. Entrez leurs valeurs: \n n1=\t");
scanf("%d",&n1);
printf("\t m2= \t");
scanf("%d",&m2);

matrice1=(int**)malloc(n1*sizeof(int));
for(i=0;i<n1;i++){
matrice1[i]=(int*)malloc(m1*sizeof(matrice1[i]));}

for(i=0;i<n1;i++)
{
for(j=0;j<m1;j++)
{
matrice1[i][j]=rand();
}
}
//creation de la matrice 2 et la remplir aleatoirement
printf(" \nLa matrice 2 est d'ordre n2xm2. Entrez leurs valeurs: \n n2=\t");
scanf("%d",&n2);
printf("\t m2= \t");
scanf("%d",&m2);

matrice2=(int**)malloc(n2*sizeof(int));
for(i=0;i<n2;i++){
matrice2[i]=(int*)malloc(m2*sizeof(matrice2[i]));}

for(i=0;i<n2;i++)
{
for(j=0;j<m2;j++)
{
matrice2[i][j]=rand();
}
}
if((n1==n2)&&(m1==m2)){

13
 for(i=0;i<n1;i++){
for(j=0;j<m1;j++){
matrice1[i][j]=matrice1[i][j]+matrice2[i][j];}
}}
else{ printf("On ne peut pas additionner deux matrices qui n'ont pas la meme taille!");}
//affichage de la matrice résultante
printf("\n La matrice résultante est:\n");
for(i=0;i<n1;i++){
for(j=0;j<m1;j++){
printf("%d",matrice1[i][j]);}
printf(" \n");}
}

______________________________________________________________________________

____________________________________ 7________________________________________
void mulmat(){
printf("\n\n-----Multiplication de deux matrices M1 et M2-----\n");

printf("________________________________________________________________\n\n");
int n1,n2,m1,m2,i,j,k;
int **matrice1,**matrice2;
//creation de la matrice 1 et la remplir aleatoirement
printf("La matrice 2 est d'ordre n1xm1. Entrez leurs valeurs: \n n1=\t");
scanf("%d",&n1);
printf("\t m2= \t");
scanf("%d",&m2);

matrice1=(int**)malloc(n1*sizeof(int));
for(i=0;i<n1;i++){
matrice1[i]=(int*)malloc(m1*sizeof(matrice1[i]));}

for(i=0;i<n1;i++)
{
for(j=0;j<m1;j++)
{
matrice1[i][j]=rand();
}
}

//creation de la matrice 2 et la remplir aleatoirement

printf(" \nLa matrice 2 est d'ordre n2xm2. Entrez leurs valeurs: \n n2=\t");
scanf("%d",&n2);
printf("\t m2= \t");
scanf("%d",&m2);

14
 matrice2=(int**)malloc(n2*sizeof(int));
for(i=0;i<n2;i++){
matrice2[i]=(int*)malloc(m2*sizeof(matrice2[i]));}

for(i=0;i<n2;i++)
{
for(j=0;j<m2;j++)
{
matrice2[i][j]=rand();
}
}
if(m1==n2){
//creation de la matrice produit
matriceP=(int**)malloc(n1*sizeof(int));
for(i=0;i<n1;i++){
matriceP[i]=(int*)malloc(m2*sizeof(matriceP[i]));}
//effectuer la multiplication
for (i=0; i<n1; i++){
for (j=0; j<m2; j++)
{
matriceP[i][j]=0;
for (k=0;k<m1; k++){
matriceP[i][j] += matrice1[i][k]*matrice2[k][j];}}
}
//Affichage de la matrice produit
for (i=0; i<n1; i++){
for (j=0; j<m2; j++)
{
printf("%d",matriceP[i][j]);}
printf("\n");}
}
else{ printf("Ce n'est pas possible ! ");}
}

Exercice 4 : Chercher l’erreur

Char*string1 ; Char string1[];
Char*string2= « second » ; Char string2[]=”second”;
String1=string2; String1=string2;

REPONSE

Le premier programme est correct . Quant au deuxième , la première ligne est fausse car on
ne peut initialiser une chaîne de caractères sans taille !

15
 TP3 Les listes chaînées

Ce TP consiste en la création d’un module, ici une liste, passant par une partie données locales ou
fichier source contenant des fonctions, un fichier header contenant les prototypes des fonctions
définis dans la bibliothèque, et enfin, le main, c’est le programme principal qui permet d’exécuter
l’ensemble des fonctions choisies par l’utilisateur.
Donc tout d’abord, on commence par la création d’un nouveau projet, (Fichier -> nouveau -> projet
->Console d’application) , et ensuite , on commence à implémenter dans ce projet les 3 fichiers
suivants : liste.h , liste.cpp et enfin mainliste.cpp

REPONSE

liste.h
#define faux 0
#define vrai 1
#define NONORDONNE 0
#define CROISSANT 1
#define DECROISSANT 2

//Nouveaux types
typedef void objet;
typedef int booleen;

//un élément de la liste

typedef struct element{
objet* reference; //référencie un objet
struct element* suivant; //élément suivant de la liste
} element;

//type liste
typedef struct liste{
element* premier; //premier élémént de la liste
element* dernier; //dernier élément de la liste
element* courant; //élément en cours de traitement (parcours de la liste)
int nbelt; //nombre d'éléments dans la liste
int type; //0:simple, 1:croissant , 2:décroissant
char* (*afficher) (objet*);
int (*comparer) (objet*,objet*);
}liste;

16
 //comparer deux chaines de caracteres
//fournit <0 si ch1<ch2; 0 si ch1=ch2; >0 sinon
int comparer (objet* objet1, objet* objet2);
char* afficher(objet* objet);
//créer la liste
liste* creerliste( int type,char* (*afficher) (objet*),int (*comparer) (objet*,objet*));
//initialiser la liste
void initliste(liste* li,int type,char* (*afficher) (objet*),int (*comparer)(objet*,objet*));
//Calculer le nombre d'éléménts de la liste
int nbelement(liste* li);
//vérifier si la liste est vide
booleen listevide(liste* li);
//Ajout en tete de liste
void insererentetedeliste(liste* li,objet* objet);
//Ajout après l'élément précédent
//insérer dans la liste li, objet après précédent
//si précédent est NULL, insérer en tête de liste
void insererapres(liste* li,element* precedent,objet* objet);
//Ajout en fin de liste
void insererenfindeliste(liste* li, objet* objet);
//Fonction ouvrir liste
void ouvrirliste(liste* li);
//Fonction finiliste
booleen finliste(liste* li);
//element courant
element* elementcourant(liste* li);
//objet courant
objet* objetcourant(liste* li);
//lister la liste
void listerliste(liste* li);
//chercher un objet
objet* chercherunobjet(liste* li, objet* objetcherche);
//retrait en tete de liste
objet* extraireentetedeliste(liste* li);
//extraire apres l'élément précédent
objet* extraireapres(liste* li, element* precedent);
//Extraire en fin de liste
objet* extraireenfindeliste(liste* li);
//extraire un objet à partir de sa référence
booleen extraireunobjet(liste* li,objet* objet);
//detruire liste
void detruireliste(liste* li);
liste.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

17
 #include"liste.h"

// comparer deux chaînes de caractères

// fournit <0 si ch1 < ch2; 0 si ch1 = ch2; >0 sinon
int comparer (objet* objet1, objet* objet2){
return strcmp ((char*)objet1,(char*)objet2);
}

char* afficher (objet* objet){

return (char*)objet;
}

// initialiser la liste pointée par li (cas général)

void initliste (liste* li, int type, char* (*afficher) (objet*), int (*comparer) (objet*, objet*)){
li -> premier = NULL;
li -> dernier = NULL;
li -> courant = NULL;
li -> nbelt = 0;
li -> type = type;
li -> afficher = afficher;
li -> comparer = comparer;
}

// créer la liste
liste* creerliste (int type, char* (*afficher) (objet*), int (*comparer) (objet*, objet*)){
liste* li = (liste*) malloc (sizeof (liste));
initliste (li, type, afficher, comparer);
return li;
}

// vérifier si la liste est vide

booleen listevide (liste* li){
return li -> nbelt == 0;
}

// Nombre d'élément de la liste

int nbelement (liste* li){
return li -> nbelt;
}

// Ajout en tete de liste

//creer un nouveau element
static element* creerelement(){
return (element*)malloc(sizeof(element));}
//ou bien return new element();

18
 void insererentetedeliste(liste* li, objet* objet){
element* nouveau = creerelement();
nouveau->reference = objet;
nouveau->suivant = li->premier;
li->premier = nouveau;
if(li->dernier ==NULL){
li->dernier = nouveau;}
li->nbelt++;}

//Ajout après l'élémént précédent

//insérer dans la liste li , objet après precedent
//si precedent est NULL, inserer en tete de liste

void insererapres(liste* li, element* precedent, objet* objet){

if(precedent ==NULL){
insererentetedeliste(li,objet);}
else{
element* nouveau = creerelement();
nouveau->reference = objet;
nouveau -> suivant = precedent -> suivant;
precedent -> suivant = nouveau;
if(precedent == li->dernier){
li->dernier = nouveau; }
li ->nbelt++;}
}

//Ajout en fin de liste

void insererenfindeliste (liste* li, objet* objet){
insererapres(li, li->dernier, objet);}

//fonction ouvrirliste
void ouvrirliste(liste* li){
li->courant = li ->premier;}

//fonction finliste
booleen finliste(liste* li){
return li->courant == NULL;}

//element courant
element* elementcourant(liste* li){
element* ptc = li -> courant;
if(li -> courant != NULL){
li -> courant = li -> courant ->suivant;}
return ptc;}

//objet courant

19
 objet* objetcourant (liste* li){
element* ptc = elementcourant(li);
return ptc == NULL ? NULL : ptc -> reference;}

//lister la liste
void listerliste(liste* li){
ouvrirliste(li);
while(!finliste (li)){
objet* objet = objetcourant(li);
printf("%s \n",li -> afficher(objet));}
}

//chercher un objet
objet* chercherunobjet (liste* li, objet* objetCherche){
booleen trouve = faux;
objet* objet; //pointeur courant
ouvrirliste(li);
while(!finliste(li)&& !trouve){
objet = objetcourant(li);
trouve = li -> comparer(objetCherche,objet) == 0;
}
return trouve ? objet : NULL;}

//retrait en tete de liste

objet* extraireentetedeliste(liste* li){
element* extrait = li -> premier;
if(!listevide(li)){
li->premier = li -> premier -> suivant;
if(li -> premier == NULL){
li -> dernier = NULL;} //liste devenue NULLe
li -> nbelt--;
}
return extrait != NULL ? extrait -> reference : NULL;}

// extraire apres l'élément precedent

//si precedent vaut NULL, on extrait le premier de la liste
// retourne NULL si l'objet a extraire n'existe pas
objet* extraireapres (liste* li, element* precedent){
if(precedent == NULL){
return extraireentetedeliste(li);}
else{
element* extrait = precedent -> suivant;
if (extrait != NULL){
precedent -> suivant = extrait -> suivant;
if (extrait == li -> dernier){
li -> dernier = precedent;}

20
 li -> nbelt--;
}

return extrait != NULL ? extrait -> reference : NULL;

}
}

// extraire en fin de liste

objet* extraireenfindeliste (liste* li){
objet* extrait;
if(listevide(li)){
extrait = NULL;}
else{ if(li -> premier == li -> dernier) //un seul élémént
{extrait = extraireentetedeliste(li);}
else{
element* ptc = li -> premier;
while (ptc -> suivant != li -> dernier){
ptc = ptc -> suivant;}
extrait = extraireapres(li,ptc);
}}
return extrait;}

//extraire un objet à partir de sa reference

booleen extraireunobjet(liste* li , objet* objet){
element* precedent = NULL;
element* ptc = NULL;
booleen trouve = faux;

ouvrirliste(li);
while(!finliste(li) && !trouve){
precedent = ptc; //repere l'element precedent
ptc = elementcourant(li);
trouve = (ptc -> reference == objet) ? vrai : faux;
}
if (trouve==faux){return faux ;}
else{

return vrai;}
}

//detruire liste
void detruireliste(liste* li){
ouvrirliste(li);
while(!finliste(li)){
element* ptc = elementcourant(li);
//free (ptc -> reference); // si on veut detruire les objets

21
 free(ptc); }
initliste(li,0,NULL,NULL);}

______________________________________________________________________________

Mainliste.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "liste.h"

int menu(){
printf("\n\n GESTION D'UNE LISTE D'ENTIERS \n\n");
printf("1 - Creer une liste \n");
printf("2 - Initialiser une liste \n");
printf("3 - Retourner le nombre des objets \n");
printf("4 - Verifier si la liste est vide \n");
printf("5 - Insertion en tete de liste \n");
printf("6 - Insertion en fin de liste \n");
printf("7 - Retrait en tete de liste \n");
printf("8 - Retrait en fin de liste \n");
printf("9 - Retrait d'un objet à partir de sa reference \n");
printf("10 - Afficher les objets de la liste \n");
printf("11 - Chercher un objet \n");
printf("12 - Destruction de la liste \n");
printf("13 - FIN \n");

printf("\n");
printf("Votre choix?");
int cod; scanf("%d",&cod); getchar();
printf("\n");
return cod;
}
main(){
int fin = 1;
liste* li = NULL;
while(fin)
{
switch(menu())
{
case 1 : li = creerliste(0,afficher,comparer);
break;

case 2 : initliste(li,0,afficher,comparer);
break;

22
 case 3 : printf("Le nombre d'elements est : %d",nbelement (li));
break;

case 4 : if(listevide(li)) printf("Liste est Vide");

else printf("Liste n'est pas vide");
break;

case 5 : printf("Tapez l'entier a inserer : ");

int* a;
a = (int*) malloc(sizeof(int));
scanf("%d",a);
insererentetedeliste(li,a);
break;

case 6 : printf("Tapez l'entier a inserer : ");

int* b;
b = (int*) malloc(sizeof(int));
scanf("%d",b);
insererenfindeliste(li,b);
break;

case 7 : int* c;
c = (int*)extraireentetedeliste(li);
if(c == NULL) printf("Liste Vide !");
else printf("L'element extrait : %d",*c);
break;

case 8 : int* d;
d = (int*)extraireenfindeliste(li);
if(d == NULL) printf("Liste Vide !");
else printf("L'element extrait : %d",*d);
break;

case 9 : printf("Tapez le nombre que vous voulez extraire : "); int e;

scanf("%d",&e);
if(extraireunobjet(li,&e)==vrai) printf("Le nombre est extrait !!");
else printf("L'element n'est pas trouve");
break;

case 10 : listerliste(li);
break;

case 11 : printf("Tapez le nombre a chercher : "); int* g; int* f;

scanf("%d",f);
g = (int*)chercherunobjet(li,f);

23
 if(g == NULL) printf("Le nombre n'est pas trouve !!");
else printf("Le nombre est trouve !!");
break;
case 12 : detruireliste(li);
printf("Liste est detruite :( ");
break;
case 13 : fin = 0;
break;
default : printf("Tapez un nombre entre 1 et 13");
break;
}} }
Exécution du Programme

24
 TP4 Liste de personnes

Dans cet exercice, on va appliquer le programme précédent sur une liste de personnes.
Donc on va ajouter 2 autre fichiers ( personne.h et personne.c ) .

personne.h

#include <string.h>
#include<stdlib.h>
typedef char ch15[16];
typedef void Objet;
typedef struct { //creer la structure Personne
ch15 nom;
ch15 prenom;
}Personne;
Personne* creerPersonne(char* nom,char* prenom); //fonction qui creer un personne
char* ecrirePersonne(Objet* objet); //pour affichier la Personne crée
int comparerPersonne(Objet* objet1,Objet* objet2);// pour comparer 2 personne a partir de
leur nom
______________________________________________________________________________
personne.c
#include <stdio.h>
#include "personne.h"
#include <string.h>

//fonction de creation d'une personne

Personne* creerPersonne(char* nom,char* prenom)

25
 {
Personne* p=new Personne();
strcpy(p->nom,nom);
strcpy(p->prenom,prenom);
return p;
}
//fonction d'affichage d'une personne
char* ecrirePersonne(Objet* objet){
Personne *p=(Personne*) objet;
char* output=(char*)malloc(sizeof(Personne));
snprintf(output,sizeof(Personne),"%s %s\n",p->nom,p->prenom);
return output;
}
//fonction de comparaison entre 2 personnes
int comparerPersonne(Objet* objet1,Objet* objet2){ //fontion
Personne *p1=(Personne*) objet1;
Personne *p2=(Personne*)objet2;
return strcmp(p1->nom,p2->nom);
}
__________________________________________________________________________
listePersonne.c (main)
#include<stdio.h>
#include"liste.h"
#include"personne.h"
int menu()
{
int cod;
printf("\n\nGESTION D'UNE LISTE DE PERSONNES\n\n");
printf("0 - Fin\n");
printf("1 - Insertion en tete de liste\n");
printf("2 - Insertion en fin de liste\n");
printf("3 - Retrait en tete de liste\n");
printf("4 - Retrait en fin de liste\n");
printf("5 - Retrait d'un element a partir de son nom\n");
printf("6 - Parcours de la liste\n");
printf("7 - Recherche d'un element a partir de son nom\n");
printf("8 - Destruction de la liste\n");
printf("\n");
printf("Votre choix?\t");
scanf("%d",&cod);
printf("\n");
return cod;
}
main()

26
 { Liste* lp=creerListe(0,ecrirePersonne,comparerPersonne);
booleen fini=faux;
while(!fini){
switch(menu()){
case 0:
fini=vrai;
break;
case 1:{
printf("nom de la personne a creer??");
ch15 nom;
scanf("%s",nom);
printf("prenom de la personne a creer??");
ch15 prenom;
scanf("%s",prenom);
Personne* nouveau=creerPersonne(nom,prenom);
insererEnTeteDeListe(lp,nouveau);

}break;
case 2:{
printf("nom de la personne a creer??");
ch15 nom;
scanf("%s",nom);
printf("prenom de la personne a creer??");
ch15 prenom;
scanf("%s",prenom);
Personne* nouveau=creerPersonne(nom,prenom);
insererEnFinDeListe(lp,nouveau);

}break;
case 3:
{
Personne* P=(Personne*) extraireEnTeteDeListe(lp);
if(P!=NULL)
{
printf("Element %s %s extrait en tete de
liste\n",P->nom,P->prenom);
}
else
{
printf("Liste est vide");
}
}
break;
case 4:
{
Personne* P=(Personne*) extraireEnFinDeListe(lp);

27
 if(P!=NULL)
{
printf("Element %s %s extrait en fin de liste\n",P->nom,P->prenom);}
else
{printf("Liste est vide");}
}
break;
case 5:
{
printf("Donnez le nom de personne a extraire:\t");
ch15 nom;
scanf("%s",nom);
Personne* P=creerPersonne(nom,"?");
Personne* P2 = (Personne*) chercherUnObjet(lp,P);
if(extraireUnObjet(lp,P2))
{
printf("Element %s %s extrait de la liste\n",P2-
>nom,P2->prenom);
}
}
break;
case 6:
listerListe(lp);
break;
case 7:
{
printf("Donnez le nom de personne a chercher:\t");
ch15 nom;
scanf("%s",nom);
Personne* P=creerPersonne(nom,"?");
Personne* P2 = (Personne*)chercherUnObjet(lp,P);
if(P2 != NULL)
{
printf("%s %s trouver dans la liste\n",P2-
>nom,P2->prenom);
}
else
{
printf("%s n'existe pas dans la liste\n",nom);
}
}break;
case 8:
detruireListe(lp);
break;
}
} return 0

28
 Exécution du Programme

Insertion en tête
de la liste Parcours de la liste

Retrait en fin de
Recherche d’un Liste
Elément

29
 TP5 Listes chaînées (POLYNÔMES)
Le type monôme est une structure (un objet) contenant un coefficient réel et un exposant
entier. Le type Polynôme correspond au type Liste.
Implémenter au langage C les fonctions du module polynôme qui permettent de créer un
monôme, de créer un polynôme , d’insérer un monôme dans un polynôme , d’afficher un
polynôme, de calculer la valeur d’un polynôme pour une valeur x donnée et de détruire un
polynôme .

polynome.h
#include "liste.h"

typedef struct
{
double coefficient;
int exposant;
}monome;
typedef liste polynome;
monome* creermonome(double coefficiant, int exposant);
char* ecriremonome(objet* objet);
int comparermonome(objet* objet1, objet* objet2);
polynome* creerpolynome();
void insererenordre(polynome* po, monome* nouveau);
void afficherpolynome(polynome* po);
double valeurpolynome(polynome* po, double x);
void detruirepolynome(polynome* po);

polynome.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "polynome.h"

//creation d'un monome

monome* creermonome(double coefficiant, int exposant)
{
monome* m = new monome();
m->coefficient = coefficiant;
m->exposant = exposant;
return m;

30
 }

//ecriture du monome
char* ecriremonome(objet* objet)
{
monome* m = (monome*)objet; //transformation du type de objet de objet* vers
monome*
char* output = (char*)sizeof(monome);
snprintf(output, sizeof(monome), "%s*x^%s", m->coefficient, m->exposant); //on
utilise snprintf pour avoir une écriture comme on le veut
return output;
}

//comparaiser des monomes via leurs exposants

int comparermonome(objet objet1, objet objet2)
{
monome* m1 = (monome*)objet1;
monome* m2 = (monome*)objet2;
if (m1->exposant > m2->exposant)
{
return 1;
}
else if (m2->exposant > m1->exposant)
{
return -1;
}
else //si leurs exposants sont identiques , on compare les coefficients
{
if(m1-> coefficiant > m2->coefficiant) { return 1;}
else if (m1-> coefficiant < m2->coefficiant) { return -1;}
else {return 0;}
}
}

//creation d'un polynome qui est semblable a la creation dune liste

polynome* creerpolynome()
{
return creerliste(1, ecriremonome, comparermonome);

//insertion en ordre!!!!!!!!!!!!!!!!!!
void insererenordre(polynome* po, monome* nouveau)
{
insererenordreliste(po, nouveau); // on a pas cette fonction dans liste
}

31
 //affichage du polynome qui est une liste de monome et donc qui est semblable a listerliste
void afficherpolynome(polynome* po)
{
listerliste(po);
}

//fonction qui calcule expo

static double expo(double x, int e)
{
double resu=1;
if (e == 0)
{
resu = 1;
}
else {
for (i = 0; i<e; i++)
{
resu *= x;
}
return resu;
}

//calculer la valeur du polynome

double valeurpolynome(polynome* po, double x)
{

double valeur=0;
while (objetcourant(po) != NULL)
{

monome* m = (monome*)objetcourant(po);
valeur += m->coefficient*expo(x, m->exposant);
}
return valeur;
}

void detruirepolynome(polynome* po)

{
detruireliste(po);
}

32
 MainPolynome.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include "liste.h"
#include "polynome.h"

int menu(){
printf("\n\n GESTION DE POLYNOME \n\n");
printf("1 - Créer un monome \n");
printf("2 - Ecrire un monome \n");
printf("3 - Comparer deux monomes \n");
printf("4 - Création d'un polynome \n");
printf("5 - Insertion en ordre \n");
printf("6 - Affichage du polynome \n");
printf("7 - Valeur du polynome \n");
printf("8 - Destruction de la liste \n");
printf("9 - FIN \n");

printf("\n");
printf("Votre choix?");
int cod; scanf("%d",&cod); getchar();
printf("\n");
return cod;
}
main(){
int fin = 1;
polynome* po = (polynome*)malloc(sizeof(polynome));
monome* mo = (monome*)malloc(sizeof(monome));
double coefficient,coefficient1,coefficientn,x;
int exposant, exposant1,exposantn;
while(fin)
{
switch(menu())
{
case 1 : printf("Veuillez entrer un coefficient : \t");
scanf("%lf",&coefficient);
printf("\n et veuillez entrer un exposant : \t");
scanf("%d",&exposant);
mo = creermonome(coefficient,exposant);
printf("Votre monome a été créé ! \n")
break;

case 2 : char* monome = ecriremonome(mo);

33
 printf(" \n %s",monome);
break;

case 3 : printf("Veuillez entrer un coefficient : \t");

scanf("%lf",&coefficient1);
printf("\n et veuillez entrer un exposant : \t");
scanf("%d",&exposant1);
monome* m1 = creermonome(coefficient1,exposant1);
printf("%d",comparermonome(m0,m1);
break;

case 4 : p0=creerpolynome();
printf("Votre polynome a été créé avec succes !");
break;

case 5 :
printf("Veuillez entrer un coefficient : \t");
scanf("%lf",&coefficientn);
printf("\n et veuillez entrer un exposant : \t");
scanf("%d",&exposantn);
monome* nouveau = creermonome(coefficientn,exposantn);
insererenordre(p0,nouveau);
break;

case 6 : afficherpolynome(po);
break;

case 7 :
printf("Veuillez saisir une valeur pour x :\t");
scanf("%f",&x);
double resultat = valeurpolynome(p0,x);
printf("\n Le calcul de votre polynome est: %f",&resultat);
break;

case 8 : detruirepolynome(p0);
printf("\n Votre polynome a été détruit avec succès!");
break;

case 9 : fin = 0;
break;

default : printf("Tapez un nombre entre 1 et 9");

break;
}
} getch();
}

34
 Exécution du Programme

35
 TP6 PILES - FILES

Une Pile est une structure de données telle que l’ajout d’un élément se fait au sommet
Et la suppression d’un élément se fait également au sommet .(LAST IN FIRST OUT =LIFO)
Une file est une structure de données telle que l’ajout d’un élément en fin de fille d’attente
Et la suppression d’un élément se fait en début de file d’attente .(LAST IN FIRST OUT =LIFO)
Le but de tp c’est implémenter la pile et la file pour un liste de personnes , donc on ajoute 2
fichier pour chaque type : pile.h et pile.c
: file.h et file.c
Et on applique Le programme pour 3 personnes .

REPONSE Pile :

Pile.h
#include "liste.h"

typedef Liste Pile;

Pile* CreerPile(int type, char* (*afficher) (Objet*), int (*comparer) (Objet*, Objet*) );
booleen pileVide(Pile *P);
void Empiler(Pile* P,Objet *O);
Objet* Depilert(Pile* P);
void ListerPile(Pile* P);
void detruirePile(Pile* P);

Pile.c

#include <stdio.h>
#include <string.h>
#include "Pile.h"

Pile* CreerPile(int type, char* (*afficher) (Objet*), int (*comparer) (Objet*, Objet*) )
{
return creerListe(type,afficher,comparer);
}

36
 booleen pileVide(Pile *P)
{return listeVide(P);}
void Empiler(Pile* P,Objet *O)
{insererEnTeteDeListe(P,O);}
Objet* Depilert(Pile* P)
{return extraireEnTeteDeListe(P);}
void ListerPile(Pile* P)
{listerListe(P);}
void detruirePile(Pile* P)
{detruireListe(P) ;}
Main
#include <stdio.h>
#include <stdlib.h>
#include "Personne.h"
#include "Pile.h"

int main(int argc, char *argv[]) {

printf("GESTION D'une Pile de personne \n");
Pile* P;
P=CreerPile(0,ecrirePersonne,comparerPersonne);
int i=1;
ch15 nom,prenom;
Personne *Pr;
while(i<4)
{
printf("Donner le nom de %d personne \n",i);
scanf("%s",nom);
printf("Donner le prenom de %d personne\n",i);
scanf("%s",prenom);
Pr= creerPersonne(nom,prenom);
Empiler(P,Pr);
i++;
}
printf("\nles elements de la pile sont:\n");
ListerPile(P);
Pr=Depilert(P);
printf("\nla dernier personnes inserer est :\n%s\t%s",Pr->nom,Pr->prenom);
printf("\nles nouvelles elements de la pile sont:\n");
ListerPile(P);
printf("\nla destruction de la pile");
detruirePile(P);
return 0;
}

37
 Exécution du Programme

REPONSE FILE :

File.h
#include "liste.h"
typedef Liste File;
File* CreerFile(int type, char* (*afficher) (Objet*), int (*comparer) (Objet*, Objet*) );
booleen fileVide(File *F);
void Enfiler(File* F,Objet *O);
Objet* Defiler(File* F);
void ListerFile(File* F);
void detruirePile(File* F);

38
 File.c
#include <stdio.h>
#include <string.h>
#include "File.h"

File* CreerFile(int type, char* (*afficher) (Objet*), int (*comparer) (Objet*, Objet*) )
{
return creerListe(type,afficher,comparer);
}
booleen FileVide(File *F) //verification si la file est vide
{return listeVide(F);}
void Enfiler(File* F,Objet *O) //enfiler depuis la file
{insererEnTeteDeListe(F,O);}
Objet* Defiler(File* F) // defiler depuis la file
{return extraireEnFinDeListe(F);}
void ListerFile(File* F) // parcours les elements du file
{ listerListe(F);}
void detruirefile(File* F) // detruire la file
{detruireListe(F);}

Main
#include <stdio.h>
#include <stdlib.h>
#include "Personne.h"
#include "File.h"

/* run this program using the console pauser or add your own getch, system("pause") or input
loop */

int main(int argc, char *argv[]) {

printf("GESTION D'une File de personne \n");

File* F;
F=CreerFile(0,ecrirePersonne,comparerPersonne);
int i=1;
ch15 nom,prenom;

Personne *Pr;
while(i<4)
{
printf("Donner le nom de %d personne \n",i);
scanf("%s",nom);

39
 printf("Donner le prenom de %d personne\n",i);
scanf("%s",prenom);
Pr= creerPersonne(nom,prenom);
Enfiler(F,Pr);
i++;}
printf("\nles elements de la File sont:\n");
ListerFile(F);
Pr=Defiler(F);
printf("\nla dernier personnes inserer est :\n%s\t%s",Pr->nom,Pr->prenom);
printf("\nles nouvelles elements de la File sont:\n");
ListerFile(F);
printf("\nla destruction de la file");
detruirefile(F);
return 0;}
Exécution du Programme

40
 TP7 Les Arbres
En nous inspirant du TP précédent , on doit implémenter :
-arbre.h : qui contient la déclaration du type arbre et les prototypes des fonctions de gestion
d’un arbre ;
-arbre.cpp : qui contient le corps des fonctions dont le prototype est défini dans arbre.h
-mainarbre.cpp : qui est le programme principal des arbres.

arbre.h
typedef void Objet;
typedef int booleen;
#define faux 0
#define vrai 1

typedef struct noeud

{
Objet* ref;
struct noeud* Gauche;
struct noeud* Droit;
}Noeud;

typedef struct
{
Noeud* racine;
char* (*afficher) (Objet*);
int (*comparer) (Objet*, Objet*);
}Arbre;

Noeud* cNd(Objet* o,Noeud* gauche,Noeud* droit);

Noeud* cF(Objet* o);

void initArbre(Arbre* A, Noeud* R, char* (*afficher) (Objet*), int (*comparer) (Objet*,

Objet*));

Arbre* creerArbre( Noeud* R, char* (*afficher) (Objet*), int (*comparer) (Objet*,

Objet*));

Arbre* creerArbreGene();

41
 Arbre* creerArbreAri();

void Prefixe(Noeud* R,char* (*afficher)(Objet*));

void Infixe(Noeud* R,char* (*afficher)(Objet*));

void Postfixe(Noeud* R,char* (*afficher)(Objet*));

Noeud* trouverNoeud(Noeud* R,Objet* o, int (*comparer) (Objet*,Objet*));

void EnLargeur(Noeud* R, char* (*afficher)(Objet*));

int taille(Noeud* R);

static int max(int a,int b);

int hauteur(Noeud* R);

arbre.c
#include <stdio.h>
#include <stdlib.h>
#include "Arbre.h"
#include "Liste.h"

Noeud* cNd(Objet* o,Noeud* gauche,Noeud* droit)

{
Noeud* nouv= (Noeud*) malloc(sizeof(Noeud));
nouv->ref=o;
nouv->Gauche=gauche;
nouv->Droit=droit;
return nouv;
}

Noeud* cF(Objet* o)
{
return cNd(o,NULL,NULL);
}

void initArbre(Arbre* A, Noeud* R, char* (*afficher) (Objet*), int (*comparer) (Objet*,

Objet*))
{

42
 A->racine= R;
A->afficher=afficher;
A->comparer=comparer;
}

Arbre* creerArbre( Noeud* R, char* (*afficher) (Objet*), int (*comparer) (Objet*,

Objet*))
{
Arbre* A=(Arbre*) malloc(sizeof(Arbre));
initArbre(A,R,afficher,comparer);
return A;
}

Arbre* creerArbreGene()
{
Noeud*
racine=cNd("Samir",cNd("Kamal",cNd("Yassine",NULL,cNd("Hind",NULL,cF("Yasmi
ne"))),cNd("Sarah",cF("Karim"),NULL)),NULL);
//Noeud*
racine=cNd("1",cNd("2",cF("4"),cNd("5",cF("7"),cF("8"))),cNd("3",NULL,cNd("6",cF("
9"),NULL)));
return creerArbre(racine,NULL,NULL);
}

Arbre* creerArbreAri()
{
Noeud* racine=cNd("-",cNd("*",cNd("+",cF("a"),cF("b")),cNd("-
",cF("c"),cF("d"))),cF("e"));
return creerArbre(racine,NULL,NULL);
}

void Prefixe(Noeud* R,char* (*afficher)(Objet*))

{
if(R!=NULL)
{
printf("%s\t",afficher(R->ref));
Prefixe(R->Gauche,afficher);
Prefixe(R->Droit,afficher);
}
}

void Infixe(Noeud* R,char* (*afficher)(Objet*))

{
if(R!=NULL)
{
Prefixe(R->Gauche,afficher);

43
 printf("%s\t",afficher(R->ref));
Prefixe(R->Droit,afficher);
}
}

void Postfixe(Noeud* R,char* (*afficher)(Objet*))

{
if(R!=NULL)
{
Prefixe(R->Gauche,afficher);
Prefixe(R->Droit,afficher);
printf("%s\t",afficher(R->ref));
}
}

Noeud* trouverNoeud(Noeud* R,Objet* o, int (*comparer) (Objet*,Objet*))

{
Noeud* pNom;
if(R==NULL)
{
pNom=NULL;
}
else if(comparer(R->ref,o) == 0)
{
pNom= R;
}
else
{
pNom = trouverNoeud(R->Gauche,o,comparer);
if(pNom == NULL) pNom=trouverNoeud(R->Droit,o,comparer);
}
return pNom;
}

void EnLargeur(Noeud* R, char* (*afficher)(Objet*))

{
Liste* li=creerListe(0,NULL,NULL);
Noeud* extrait=NULL;
insererEnFinDeListe(li,R);
while(!listeVide(li))
{
extrait=(Noeud*) extraireEnTeteDeListe(li);
printf("%s\t",afficher(extrait->ref));
if(extrait->Gauche != NULL)
insererEnFinDeListe(li,extrait->Gauche);
if(extrait->Droit != NULL)

44
 insererEnFinDeListe(li,extrait->Droit);
}
}

int taille(Noeud* R)
{
if(R == NULL)
return 0;
else
{
return 1 + taille(R->Gauche) + taille(R->Droit);
}
}

static int max(int a,int b)

{
if(a>b)
return a;
else
return b;
}

int hauteur(Noeud* R)
{
if(R == NULL)
{
return 0;
}
else
{
return 1 + max(hauteur(R->Gauche),hauteur(R->Droit));
}
}
mainarbre.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Arbre.h"

char* afficher(Objet* O)
{
char* N= (char*) O;
return N;

45
 }

int comparer(Objet* O1,Objet* O2)

{
char* N1= (char*) O1;
char* N2= (char*) O2;
return strcmp(N1,N2);
}

int menu()
{
int rep;
printf("\n\nGESTION D'ARBRES BINAIRES\n\n");
printf("0 - Fin\n");
printf("\n");
printf("1 - Creation de l'arbre genealogique\n");
printf("2 - Creation de l'arbre de l'expression arithmetique\n");
printf("\n");
printf("3 - Parcours prefixe\n");
printf("4 - Parcours infixe\n");
printf("5 - Parcours postfixe\n");
printf("6 - Trouver noeud\n");
printf("7 - Taille\n");
printf("8 - Hauteur\n");
printf("9 - Parcours En Largeur\n");
printf("\n");
printf("Votre choix?\t");
scanf("%d",&rep);
printf("\n");
return rep;
}

int main(int argc, char *argv[]) {

booleen fini = faux;
Arbre *A1=NULL,*A2=NULL;
Noeud *N1=NULL,*N2=NULL;
char chercher[20];

while(!fini)
{
switch(menu())
{
case 0 :
fini = vrai;
break;

46
 case 1:
{
A1 = creerArbreGene();
}
break;
case 2:
{
A2 = creerArbreAri();
}
break;
case 3:
if(A1!=NULL)
{
printf("\nParcours prefixe de l'arbre genealogique\n");
Prefixe(A1->racine,afficher);
}

if(A2!=NULL)
{
printf("\nParcours prefixe de l'arbre arithmetique\n");
Prefixe(A2->racine,afficher);
}
break;
case 4:
if(A1!=NULL)
printf("\nParcours infixe de l'arbre genealogique\n");
Infixe(A1->racine,afficher);
if(A2!=NULL)
{
printf("\nParcours infixe de l'arbre arithmetique\n");
Infixe(A2->racine,afficher);
}
break;
case 5:
if(A1!=NULL)
{
printf("\nParcours postfixe de l'arbre genealogique\n");
Postfixe(A1->racine,afficher);
}
if(A2!=NULL)
{
printf("\nParcours postfixe de l'arbre arithmetique\n");
Postfixe(A2->racine,afficher);
}
break;
case 6:

47
 printf("donner le nom a rechercher:\t");
scanf("%s",chercher);
if(A1!= NULL)
{
N1=trouverNoeud(A1-
>racine,chercher,comparer);
if(N1!=NULL)
{
printf("%s existe dans l'arbre genealogique\n",N1->ref);
}
else
{
printf("%s n'existe pas dans l'arbre genealogique\n",chercher);
}
}
if(A2!= NULL)
{
N2=trouverNoeud(A2-
>racine,chercher,comparer);
if(N2!=NULL)
{
printf("%s existe dans l'arbre arithmetique\n",N2->ref);
}
else
{
printf("%s n'existe pas dans l'arbre arithmetique\n",chercher);
}
}
break;
case 7:
if(A1 != NULL)
{
printf("La taille de l'arbre genealogique est: %d\n",taille(A1->racine));
}
if(A2 != NULL)
{
printf("La taille de l'arbre arithmetique est: %d\n",taille(A2->racine));
}
break;
case 8:
if(A1 != NULL)
{
printf("L'hauteur de l'arbre genealogique est:
%d\n",hauteur(A1->racine));
}
if(A2 != NULL)

48
 {
printf("L'hauteur de l'arbre arithmetique est: %d\n",hauteur(A2->racine));
}
break;
case 9:
if(A1 != NULL)
{
printf("parcours en largeur de l'arbre genealogique\n");
EnLargeur(A1->racine,afficher);
}
if(A2 != NULL)
{
printf("parcours en largeur de l'arbre arithmetique\n");
EnLargeur(A2->racine,afficher);
}
break;
}
}

return 0;}

Exécution du Programme

49
 TP8 Les Graphes

Un graphe est une structure de données composée d’un ensemble de sommets, et d’un
ensemble de relations entre ces sommets .
Dans ce TP , on va implémenter un programme adéquat comme demandé .

Graphemat.h
#include <stdio.h>

typedef int booleen;

#define faux 0
#define vrai 1
#include "limits.h"
typedef char NomSom[20];
#define INFINI INT_MAX
typedef int* Matrice;

typedef struct {
int n;
int nMax;
booleen value;
NomSom* nomS;
Matrice element;
Matrice valeur;
booleen* marque;
} GrapheMat;

GrapheMat* creerGrapheMat (int nMax, int value);

void detruireGraphe (GrapheMat* graphe);
void ajouterUnSommet (GrapheMat* graphe, NomSom nom);
void ajouterUnArc (GrapheMat* graphe, NomSom somD,NomSom somA, int cout);
void ecrireGraphe (GrapheMat* graphe);
void parcoursProfond (GrapheMat* graphe);

Graphemat.c
#include "graphemat.h"

50
 #include <string.h>
#include <stdlib.h>

static void initMarque(GrapheMat* graphe) {

for (int i=0; i<graphe->n; i++) graphe->marque [i] = faux;
}

GrapheMat* creerGrapheMat(int nMax, int value) {

// allocation de graphe
GrapheMat* graphe = (GrapheMat*) malloc (sizeof (GrapheMat));
graphe->n = 0;
graphe->nMax = nMax;
graphe->value = value;
graphe->nomS = (NomSom*) malloc (sizeof(NomSom) *nMax);
graphe->marque = (booleen*) malloc (sizeof(booleen) *nMax);
graphe->element = (int*) malloc (sizeof(int)*nMax*nMax);
graphe->valeur = (int*) malloc (sizeof(int)*nMax*nMax);
// initialisation par défaut
for (int i=0; i<nMax; i++) {
for (int j=0; j<nMax; j++) {
graphe->element [i*nMax+j] = faux;
graphe->valeur [i*nMax+j] = INFINI;
}
}
for (int i=0; i<nMax; i++) graphe->valeur [i*nMax+i] = 0;
initMarque (graphe);
return graphe;
}

void detruireGraphe(GrapheMat* graphe) {

free (graphe->nomS);
free (graphe->marque);
free (graphe->element);
free (graphe->valeur);
free (graphe);
}

static int rang(GrapheMat* graphe, NomSom nom) {

int i = 0;
booleen trouve = faux;
while ( (i<graphe->n) && !trouve) {
trouve = strcmp (graphe->nomS [i], nom) == 0;
if (!trouve) i++;

51
 }
return trouve ? i : -1;
}

void ajouterUnSommet(GrapheMat* graphe, NomSom nom) {

if (rang (graphe, nom) == -1) {
if (graphe->n < graphe->nMax) {
strcpy (graphe->nomS [graphe->n++], nom);
} else {
printf ("\n Nombre de sommets > %d\n", graphe->nMax);
}
} else {
printf ("\n %s déjà défini\n", nom);
}
}

void ajouterUnArc(GrapheMat* graphe, NomSom somD, NomSom somA, int cout) {

int nMax = graphe->nMax;
int rd = rang (graphe, somD);
int rg = rang (graphe, somA);
graphe->element [rd*nMax+rg] = vrai;
graphe->valeur [rd*nMax+rg] = cout;
}

void ecrireGraphe(GrapheMat* graphe) {

int nMax = graphe->nMax;
for (int i=0; i<graphe->n; i++) printf ("%s ", graphe->nomS[i]);
printf (";\n");
for (int i=0; i<graphe->n; i++) {
printf ("\n%s : ", graphe->nomS[i]);
for (int j=0; j<graphe->n; j++) {
if (graphe->element [i*nMax+j] == vrai) {
printf ("%s ", graphe->nomS[j]) ;
if (graphe->value) {
printf (" (%3d) ", graphe->valeur [i*nMax+j] );
}
}
}
printf (";");
}
}

static void profondeur(GrapheMat* graphe, int numSommet) {

int nMax = graphe->nMax;
graphe->marque [numSommet] = vrai;
printf ("%s\n", graphe->nomS [numSommet]);

52
 for (int i=0; i<graphe->n; i++) {
if ( (graphe->element [numSommet*nMax+i] == vrai)
&& !graphe->marque [i] ) {
profondeur(graphe, i);
}
}
}

void parcoursProfond(GrapheMat* graphe) {

initMarque (graphe);
for (int i=0; i<graphe->n; i++) {
if (!graphe->marque [i]) profondeur (graphe, i);
}
}

MainGraphemat.c
#include "graphemat.h"
#include <stdlib.h>
#include <string>

int menu () {
printf ("\n\n Graphes \n");
printf (" -------\n\n");
printf (" 0 - Fin du programme\n");
printf (" 1 - Creer la graphe\n");
printf (" 2 - Detruire la graphe\n");
printf (" 3 - Ajouter un sommet\n");
printf (" 4 - Ajouter un arc\n");
printf (" 5 - Ecrire graphe\n");
printf (" 6 - Parcourir en profondeur\n");
printf ("\n --------------------------------- \n");
printf ("\n Votre choix : ");
int cod; scanf ("%d", &cod); getchar();
printf ("\n\n");
return cod;
}

main()
{
GrapheMat* graphe1 ;

booleen fini = faux;

while (!fini) {
switch (menu()) {
case 0 :

53
 fini = vrai;
break;

case 1 :{
graphe1 = creerGrapheMat(4,0);
break;
}
case 2 :{
detruireGraphe (graphe1);
break;
}
case 3 :{
printf(" Donner le nom du sommet\n");
NomSom x;
gets(x);
ajouterUnSommet (graphe1,x);
break;
}

case 4 :{
NomSom x1,x2;
int x3;
printf(" Donner le premier sommet\n");
gets(x1);
printf(" Donner le deuxieme sommet\n");
gets(x2);
printf("Donner l'arc\n");
scanf("%d",&x3);
ajouterUnArc (graphe1,x1,x2,x3);
break;
}
case 5 :{
ecrireGraphe (graphe1);
break;
getchar();
}
case 6 :{
parcoursProfond (graphe1);
break;
}
default: printf("choisir un nombre entre 0 et 6 !! ");
getchar();
}
}
}

54
 Exécution du Programme

55