1LISI ASD 2 Mme. R.

BOUHOUCH

Types de données abstrais

I- Pile :
La pile est une liste composée d’éléments homogènes qui ne peut être accédé que d’un seul
bout. L’ajout ou le retrait d’un élément se font à partir du sommet de la Pile. Le dernier élément
sur la Pile sera le premier élément retiré de la pile. On dit alors que la pile est une liste de type
LIFO (Last In First Out). La structure Pile est dite aussi TAD (Type Abstrait de Données). Elle
n’est pas connue par le langage de programmation. Il faut donc implémenter si on veut l’utiliser
dans un programme. Pour manipuler une pile, nous avons besoin des fonctions suivantes :
- InitPile : Initialiser une pile
- Push : Ajouter un élément sur la pile
- Pop : Prendre un élément du haut de la pile
- emptyPile : qui retourne TRUE si la pile est vide
Exemple:
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
struct element {
int ent;
};
struct node {
struct element data;
struct node * next;
};
Typedef struct {
Struct node * sommet ;
} Pile;
/*Prototype des fonctions*/
Void InitPile (Pile * pl) ;
int enmptyPile (Pile pl) ;
void push (Pile *pl, struct element nv) ;
int pop (Pile *pl) ;
struct element sommet (Plile pl) ;
/*Fonction main*/
Void main () {

1
1LISI ASD 2 Mme. R.BOUHOUCH

Pile pl ;
Struct element nv ;
Clrscr() ;
InitPile (&pl) ;
/* Remplissage de la pile jusqu’à ce que l’utilisateur saisie -1*/
Scanf(‘’%d’’, &nv.ent) ;
while (nv.ent != -1) {
push(&pl, nv) ;
scanf(‘’%d’’, &nv.ent);
}
/*affichage dans l’ordre inverse des elements*/
While ( !emptPile(pl)) {
printf(‘’%d\t’’, sommet(pl).ent) ;
pop (&pl) ;
}
getch() ;
}
/*Fonction InitPile pour initialiser le pile*/
Void InitPile (Pile *pl) {
/*il suffit de mettre le pointeur sommet à null*/
Pl->sommet=NULL ;
}
/* Fonction emptyPile retourne 1 si la pile est vide, 0 sinon*/
Int emptyPile (Pile pl) {
return( pl.sommet==NULL) ;
}
/* Fonction push pour empiler nv au sommet de la pile*/
Void push (Pile *pl, struct element nv) {
/* creer un noeud vide poite par q*/
Struct node *q ;
q=(struct node *) malloc (sizeof(struct node)) ;
/* Remplir ce noeud */
q->data=nv;

2
1LISI ASD 2 Mme. R.BOUHOUCH

/*Empiler q au sommet de la pile */

q->next=pl->sommet ;
pl->sommet=q ;
}
/*Fonction pop pour retirer le sommet de la pile*/
Int pop (Pile *pl) {
Struct node * q ;
If(emptyPile(*pl)==0) {
q=pl->sommet ;
pl->sommet=q->next ;
free(q) ;
return 1 ;
}
Else
return 0 ; /*pour dire que la pile est vide*/
}
/*Fonction sommet qui retourne la valeur de l’element au sommet de la
pile*/
Struct element sommet (Pile pl) {
return (pl.sommet->data) ;
}

II- Les Filles

Une FILE est une liste composée d’éléments homogènes et pouvant être accédé par deux bouts.
L’ajout d’un élément se fait à la fin de la file et le retrait se fait à partir de la tête de la file. Le
premier élément mis dans la file sera le premier élément retiré de la file. On dit alors qu’une
file est une liste FIFO (First In First Out). La structure FILE est un TAD aussi. Elle n’est pas
connue par le langage de programmation. Il faut donc l’implémenter si on veut l’utiliser dans
un programme. Pour manipuler une file nous avons besoin des opérations suivantes :
- initFile : pour initialiser la file
- emptyFile : pour tester si la file est vide ou non
- Put : pour ajouter un élément à la file
- Get : pour prendre un élément de tête de la file
Exemple :
#include<stdio.h>
#include<conio.h>

3
1LISI ASD 2 Mme. R.BOUHOUCH

#include<malloc.h>
struct element {
int ent;
};
struct node {
struct element data;
struct node * next;
};
Struct File {
Struct node * tete ;
Struct node * queue ;
} ;
/* Prototypes des fonctions*/
Void initFile (struct File *fl) ;
Int emptyFile (struct File fl);
Void Put (struct File *fl, struct element nv);
Int Get (struct File *fl, struct element *elem);
/* Fonction main*/
Void main () {
Struct File fl;
Struct element nv ;
Struct node * n ;
Char c ;
Clrscr () ;
initFile (&fl) ;
/*Remplissage de la file jusqu’à ce que l’utilisateur saisi -1*/
printf (‘’Tapez p pour enfiler , g pour defiler, autre pour sortir :
\n’’) ;
fflush (stdin) ;
while (c==getchar( )) {
if (c==’p’) {
scanf (“%d”, &nv.ent);
put (&fl, nv);

4
1LISI ASD 2 Mme. R.BOUHOUCH

}
else if (c==’g’) {
if (Get (&fl, &nv))
printf (“--%d—\n”, nv.ent);
else
printf (“File vide \n”);
}
else
break;
printf (‘’Tapez p pour enfiler , g pour defiler, autre pour sortir :
\n’’) ;
fflush (stdin) ;
}
Getch () ;
}
/*Fonction InitFile*/
Void initFile (struct File *fl) {
/* il suffit de mettre les pointeurs de haut de file à nulle*/
fl->tete=NULL ;
fl->queue= NULL ;
}
/*Fonction emptyFile retourne 1 sil la file est vide 0 sinon*/
Int emptyFile (Struct File fl) {
return (fl.tete==NULL)) ;
}
/* Fonction Put pour ajouter nv au sommet de la file*/
Void Put (struct File *fl, struct element nv) {
/*creer un noeud vide pointé par q*/
Struct node * q ;
q=(struct node *) malloc (sizeof(struct node)) ;
/*rempilr ce noeud*/
q->data=nv;
q->next=NULL;

5
1LISI ASD 2 Mme. R.BOUHOUCH

if (emptyFile(*fl)) {
fl->tete=q;
fl->queue=q;
}
else {
fl->queue->next=q;
fl->queue=q;
}
}
/* Fonction Get pour retirer le sommet de la file*/
Int Get (struct file *fl, struct element *elem) {
Struct node * q;
If (! emptyFile (*fl)) {
q= fl->tete;
fl->tete=fl->tete->next;
*elem=q->data;
free(q);
if ( emptyFile (*fl))
fl->queue=NULL;
return 1;
}
else
return 0;
}

III-Les Arbres
Un arbre binaire est un graphe qui admet une racine et sans cycle et dont chaque nœud admet
deux fils : fils droit et fils gauche. On peut représenter un arbre binaire sous la forme d’une liste
chainée mais non linéaire. Chaque nœud sera composé de 3 champs : un champ pour la donnée,
et deux champs pointeurs l’un pour le fils droit et l’autre pour le fils gauche. La structure de
donnée arbre contient un seul pointeur ‘racine’ qui donne le premier élément de l’arbre. L’une
des méthodes de parcours d’un arbre binaire s’appelle la méthode de parcours ‘infixe’ et
consiste à ne considérer un élément qu’après avoir considéré son fils gauche, puis on considère
l’élément lui-même puis le fils droit.
Un arbre binaire de recherche est un arbre binaire dans lequel chaque nœud est supérieur à son
fils gauche et inférieur à son fils droit et il n’y a pas de nœuds égaux. Un arbre binaire de

6
1LISI ASD 2 Mme. R.BOUHOUCH

recherche est intéressant puisqu’il est toujours possible de connaître dans quelle branche de
l’arbre se trouve un élément et de proche en proche le localiser dans l’arbre. On peut aussi
utiliser un arbre binaire de recherche pour ordonner une liste d’éléments. Pour travailler avec
un arbre binaire de recherche, on aura besoin des primitives suivantes :
- initArbre : initialiser un arbre. Cette fonction sera appelée une seule fois avant de
commencer la construction d’un arbre.
- tailleArbre : une fonction qui renvoie le nombre de nœuds se trouvant dans l’arbre.
- tailleElemArbre : une fonction qui renvoie le nombre d’éléments se trouvant dans
l’arbre.
- chercherArbe : fonction qui permet de chercher un élément existe ou non dans l’arbre.
- insererArbe : Insérer l’élément dans l’arbre
Exemlpe :
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
Struct node {
Int data;
Struct node *left;
Struct node *right;
Int nbr;
};
Struct arbre {
Struct node *racine;
};
/* Prototypes des fonctions*/
Void InitArbre (atruct arbre *a) ;
Int tailleArbre (struct node *a) ;
Int tailleElemArbre (struct node *a) ;
Int chercherArbre ( struct arbre *a, int x) ;
Int chercher (struct node *parent, intx) ;
Int insererArbre (struct arbre *a, int x) ;
Int inserer (struct node **parent, int x) ;
Void affichInfix (struct arbre a) ;
Void affich (struct node *a) ;
/* Fonction main*/

7
1LISI ASD 2 Mme. R.BOUHOUCH

Void main () {
Struct arbre ar ;
Int i ;
Clrscr() ;
initArbre (&ar) ;
/*Remplissage de l’arbre jusqu’à saisi du chiffre -1*/
While (scanf(‘’%d’’, &i) )){
If (i!=-1) insererArbe (&ar, i);
else break;
}
printf (‘’le nombre de noeuds dans l arbre est %d\n”,
tailleArbre (ar.racine));
printf (‘’ le nombre de elements de l arbre est %d\n’’,
tailleElemArbre (ar.racine));
affichInfix (ar) ;
printf (‘’\n Donner l element a chercher:\n’’) ;
scanf (‘’ %d’’, &i) ;
if (chercerArbre (&ar, i))
printf (‘’l element se trouve dans l arbre’’);
else
printf (‘’l elent ne se trouve pas dans l arbre ‘’) ;
getch() ;
}
/* Fonction initArbre*/
Void initArbre ( atruct arbe *a) {
a->racine= NULL ;
}
/*Fonction insererArbre pour inserer un element */
Int inserArbe (struct arbre *a, int x) {
Int k ;
k= inserer (&a->racine, x) ;
return k ;
}

8
1LISI ASD 2 Mme. R.BOUHOUCH

/* Fonction inserer: Fonction recursive*/

Int inserer ( struct node **parent, int x) {
If (( *parent)==NULL) {
(*parent)=(struct node *) malloc (sizeof (struct node)) ;
(*parent)->left=NULL;
(*parent)->right=NULL;
(*parent)->data=x;
(*parent)->nbr=1;
return 1;
}
else
if ( x == (*parent)->data) {
((*parent)->nbr)++;
return 0;
}
else
if (x > (*parent)->data) {
return (inserer(&((*parent)->right, x));
}
else {
return (inserer(&((*parent)->left, x));
}
}
/* Fonction affichInfix pour afficher les elements de l arbre avec
un parcours infix*/
Void affichInfix ( struct arbre a) {
affich (a.racine) ;
}
/* fonction affich : fonction récursive*/
Void affich ( struct node * arn) {
int i;
if (arn != NULL) {
affich (arn->left);

9
1LISI ASD 2 Mme. R.BOUHOUCH

for (i=1; i<= arn->nbr; i++)

printf (‘’| %d |’’, arn->data);
affich (arn->right);
}
}
/* Fonction tailleAbre: function récursive pour le calcul du nombre
de nœuds dans l arbre*/
Int tailleArbre (struct node *a) {
Int t ;
If (a== NULL)
t=0 ;
else
t=1+tailleArbre(a->left) + tailleArbe (a->right) ;
return t;
}
/* Fonction tailleElemArbre : fonction récursive pour le calcul du
nombre d’éléments dans l’arbre*/
Int tailleElemArbre ( struct node *a) {
Int t ;
If (a== NULL) t=0 ;
else
t=a->nbr + tailleElemArbre (a-> left) + tailleElemArbre
(a->right) ;
return t ;
}
/* fonction chercherArbre pour chercher un element dans un arbre
avec un parcourt infix*/
Int chercherArbre (struct arbre *a, int x) {
Return chercher (a->racine, x) ;
}
/* Fonction chercher: function recursive*/
int chercher ( struct node * parent, int x) {
int find ;
if (parent == NULL) find=0 ;

10
1LISI ASD 2 Mme. R.BOUHOUCH

else
if (x== parent->data)
find =1 ;
else
if (x>parent->data)
find = chercher ( parent ->right, x) ;
else
find = chercher ( parent ->left, x) ;
return find;
}

11