Département d’Informatique

Faculté des Sciences, Université Ibn Zohr

Agadir

Exercices Corrigés

Algorithmique & Structures de

Données

Mohamed El Ansari

Filière : Sciences Mathématiques et Informatique

(SMI)

Semestre 4

Printemps 2013
 Ce document propose des exercices corrigés en algorithmique & structures de données
pour la filière Sciences Mathématiques et Informatique (SMI). Le cours est dispensé en semstre 4.

M. El Ansari, Faculté des Sciences, Agadir 1 Filière SMI

Table des matières

1 Exercices proposés 3

1.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.5 Exercice 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.6 Exercice 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.7 Exercice 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.8 Exercice 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.9 Exercice 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Solution des exercices proposés 6

2.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.5 Exercice 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.6 Exercice 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.7 Exercice 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.8 Exercice 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.9 Exercice 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2
Chapitre 1

Exercices proposés

1.1 Exercice 1

La suite de Fibonacci est une série d’entiers : 0, 1, 1, 2, 3, 5, 8, 21, 34, 55, 89 ...

Chaque élément de la série est la somme des deux éléments qui le précèdent. La suite de
Fibonacci est définie comme suit :
(
N si N = 0, 1
F ib(N ) =
F ib(N − 2) + F ib(N − 1) si N >1

1. Donner la version recursive de la fonction de Fibonacci.

2. Donner la version itérative de la fonction de Fibonacci.
3. Est ce que la version recursive est efficace ? Pourquoi ?

1.2 Exercice 2
1. Donner une fonction récursive som permettant de calculer :
1 4 9
0+ + + + ...
2 3 4
Exemples :
som(0)=0, som(1)=0+(1/2), som(2)=0+(1/2)+(4/3), som(3)=0+(1/2)+(4/3)+(9/4)
2. Donner sa complexité en nombre d’additions.

1.3 Exercice 3
1. Donner une fonction recursive SOM permettant de calculer la somme suivante :
1 1 1 1 1
1− + − + − + ....
2 3 4 5 6
Exemple : SOM(1)=1, SOM(2)=1- 21 , SOM(3)=1- 12 + 1
3
La fonction SOM calcule SOM(N) pour tout N >= 1.
2. Donner la complexité de la fonction SOM. On tient compte uniquement des opérations
d’additions et soustractions.

3
1.4. EXERCICE 4 CHAPITRE 1. EXERCICES PROPOSÉS

1.4 Exercice 4

On se donne une liste chaı̂née L, d’entiers, dont les noeuds ayant la structure suivante :

struct sliste {
int data;
struct sliste * suiv;
};
typedef struct sliste Liste;

1. Ecrire deux fonctions d’insertion des éléments dans la liste L :

(a) Ajout en tête de la liste L : Liste* insere_tete(Liste *lis, int donnee)
(b) Ajout en queue de la liste L : Liste* insere_queue(Liste *lis, int donnee)
2. Donner la complexité des deux fonctions insere_tete et insere_queue.
3. Ecrire une fonction int getElmt(Liste *lis) qui retourne la valeur du noeud en queue
de la liste L. La fonction retourne 0 si la liste L est vide.
4. Ecrire une fonction qui supprime le noeud en queue et le noeud en tête de la liste L.

1.5 Exercice 5

Considérons une pile de réels dont les noeuds ayant la structure suivante :

typedef struct UnePile {

float valeur;
struct UnePile * suiv;
} UnePile;

1. Donner une fonction Empiler qui permet d’empiler un réel val dans une pile P.
2. Supposons que nous nous disposons des déclarations suivantes dans un programme principal :
UnePile * A = NULL;
float a = 9.5;
Donner l’instruction permettant d’appeler la fonction Empiler afin d’empiler la valeur de a
dans la pile A.

1.6 Exercice 6
1. Donner une fonction recursive permettant de calculer le nombre d’éléments d’une liste.
Donner sa complexité.
2. Donner une fonction permettant de fusionner deux listes qui sont triées par ordre croissant.
La liste résultante doit être elle même triée par ordre croissant. La fonction reçoit deux listes
triées et retourne une liste triée. Les deux listes passées en paramètres ne doivent pas être
conservées par la fonction : il est encouragé de réutiliser leurs maillons pour venir les chaı̂ner
au bon endroit dans la liste chaniée résultat.

M. El Ansari, Faculté des Sciences, Agadir 4 Filière SMI

1.7. EXERCICE 7 CHAPITRE 1. EXERCICES PROPOSÉS

1.7 Exercice 7

Supposons que nous disposons d’une pile P d’entiers. Nous souhaitons renverser les éléments de
P en utilisant deux méthodes différentes :
1. Donner une fonction en C permettant de renverser les éléments de P en utilisant une pile
auxilaire (méthode 1).
2. Donner une fonction en C permettant de renverser les éléments de P en utilisant une file
auxilaire (méthode 2).
Exemple de renversion : la pile contenant les éléments 2,3,-1,0,9 deviendra 9,0,-1,3,2 après
renversion.

1.8 Exercice 8

On suppose que nous nous disposons d’une liste chaı̂née d’entiers qui peut être vide ou non vide
(cas général). Nous souhaitons implémenter les fonctions ci-dessous.
1. Donner une fonction qui a pour but le tri des éléments d’une liste par ordre décroissant. La
fonction doit agir directement sur la liste fournie en arguement.
2. Donner une fonction qui insère un entier dans une liste triée par ordre décroissant. La
fonction doit chercher la position convenable pour l’insertion de l’entier afin que la liste
reste triée par ordre décroissant. La fonction doit agir directement sur la liste fournie en
argument. La fonction reçoit un entier et la création du noeud s’effectuera dans la fonction.
3. Ecrire une fonction qui reçoit deux listes L1 et L2 et retourne 1 si la liste L1 est un début
de la liste L2 et 0 sinon.
4. En déduire une fonction qui retourne 1 si la liste L1 est une partie de la liste L2 et 0 sinon.

1.9 Exercice 9

Supposons que nous nous disposons d’un arbre binaire de recherche (ABR) d’entiers.
1. On souhaite récuperer l’adresse d’une clé (entier stocké dans un noeud de l’ABR). Si la clé
figure dans l’ABR la fonction retourne son adresse, sinon la fonction return 0. Ecrire une
fonction qui retourne l’adresse d’une clé d’un ABR.
2. Ecrire une fonction qui compare deux arbres binaires. La fonction renvoie une valeur nulle
si et seulement si les deux arbres binaires ont la même structure d’arbre et qu’ils portent les
mêmes valeurs aux noeuds qui se correspondent.

M. El Ansari, Faculté des Sciences, Agadir 5 Filière SMI

Chapitre 2

Solution des exercices proposés

2.1 Exercice 1

La suite de Fibonacci est une série d’entiers : 0, 1, 1, 2, 3, 5, 8, 21, 34, 55, 89 ...

Chaque élément de la série est la somme des deux éléments qui le précèdent. La suite de
Fibonacci est définie comme suit :
(
N si N = 0, 1
F ib(N ) =
F ib(N − 2) + F ib(N − 1) si N >1

1. Donner la version recursive de la fonction de Fibonacci.

int Fibonacci(int number)
{
if (number <= 1)
return number;
else
return Fibonacci(number - 2) + Fibonacci(number - 1);
}
2. Donner la version itérative de la fonction de Fibonacci.
int Fibonacci(int number)
{
int current;
int previous;
int temp;
if (number <= 1)
return 1;
else
{
previous = 0;
current = 1;
for (int count = 2; count <= number; count++)
{
temp = previous;
previous = current;
current = temp + previous;
}
return current;

6
2.2. EXERCICE 2 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

}
}
3. Est ce que la version recursive est efficace ? Pourquoi ?
la méthode recursive n’est pas efficace puisque il y a redondance dans les calculs.

2.2 Exercice 2
1. Donner une fonction récursive som permettant de calculer :
1 4 9
0+ + + + ...
2 3 4
Exemples :
som(0)=0, som(1)=0+(1/2), som(2)=0+(1/2)+(4/3), som(3)=0+(1/2)+(4/3)+(9/4)
float sum(int n)
{
if (n==0) return 0;
else
return (float) (n*n)/(n+1) + sum(n-1);
}

2. Donner sa complexité en nombre d’additions. Les opérations qui interveiennent dans la

fonction sont +, - et /.
Pour n = 0, 0 opérations
Pour n = 1, 4 opérations
Pour n = 2, 4 + 4(n=1) = 8 = 2x4 opérations
Pour n = 3, 4 + 8(n=2) = 12 = 3x4 opérations
Pour n qcq on a besoin de 4xn opérations
Donc la complexité est O(n).

2.3 Exercice 3
1. float SOM(int n)
{
if (n==1) return 1;
else if (n%2)
return SOM(n-1) + (float)1/n;
else
return SOM(n-1) - (float)1/n;
}
2. T(n=1) = 0
T(n=2) = T(1) + 1 = 1
T(n=3) = T(2) + 1 = 2
.
.
T(n) = n - 1
La complexité est O(n).

M. El Ansari, Faculté des Sciences, Agadir 7 Filière SMI

2.4. EXERCICE 4 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

2.4 Exercice 4

On se donne une liste chaı̂née L, d’entiers, dont les noeuds ayant la structure suivante :

struct sliste {
int data;
struct sliste * suiv;
};
typedef struct sliste Liste;

1. Ecrire deux fonctions d’insertion des éléments dans la liste L :

(a) Liste* insere_tete(Liste *lis, int donnee)
{
Liste *elem = 0;
elem = (Liste*)malloc(sizeof(Liste));
if (!elem) {
printf("Probeme allocation!\n");
exit(0);
}
elem->data = donnee;
if (lis == 0) /* liste vide */
elem->suiv = 0;
else /* liste non vide */
elem->suiv = lis;
lis = elem;
return lis;
}
(b) Liste* insere_queue(Liste *lis, int donnee)
{
Liste *elem = 0, *p = lis;
elem = (Liste*)malloc(sizeof(Liste));
if (!elem) {
printf("Probeme allocation!\n");
exit(0);
}
elem->data = donnee;
elem->suiv = 0;

/* liste vide */
if (!lis) return elem;

/* liste non vide */

while(p->suiv) p = p->suiv;
p->suiv = elem;
return lis;
}
2. Donner la complexité des deux fonctions insere_tete et insere_queue.
— La compexité de insere_tete est O(1) puisque l’insertion s’effectue directement sans
parcourir les noueds de la liste.
— La compexité de insere_queue est O(n) puisque il faut parcourir tous les éléments de
la liste avant l’insertion du nouveau élément.

M. El Ansari, Faculté des Sciences, Agadir 8 Filière SMI

2.4. EXERCICE 4 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

3. int getElmt(Liste *lis)

{
Liste * p = lis;
/* liste vide */
if (!p) return 0;

/* liste non vide */

while(p->suiv) p = p->suiv;
return p->data;
}

M. El Ansari, Faculté des Sciences, Agadir 9 Filière SMI

2.4. EXERCICE 4 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

4. Liste * SupprimeTeteQueue(Liste * lis)

{
Liste * Tete = lis, *PrecQueue = lis, *Queue;

/* Liste vide */
if (!lis) return 0;

/* liste comporte un seul element */

if (!lis->suiv) {
free(lis);
return 0;
}

/* liste comporte plus d’un lement */

while ((PrecQueue->suiv)->suiv) PrecQueue = PrecQueue->suiv;

Queue = PrecQueue->suiv;
if (Tete->suiv == Queue) { /* liste comporte 2 elemnts */
free(Tete);
free(Queue);
lis = 0;
return lis;
}
else {
/* supprimer tete */
lis = lis->suiv;
free(Tete);

/* supprimer queue */
free(Queue);
PrecQueue->suiv = 0;
return lis;
}
}
Une autre proposition
void * SuppTeteQueue(Liste ** lis)
{
Liste * Tete = *lis, *PrecQueue = *lis, *Queue;

/* Liste vide */
if (!Tete) return 0;

/* liste comporte un seul element */

if (!Tete->suiv) {
free(Tete);
*lis = 0;
}

/* liste comporte plus d’un lement */

while ((PrecQueue->suiv)->suiv) PrecQueue = PrecQueue->suiv;

Queue = PrecQueue->suiv;

M. El Ansari, Faculté des Sciences, Agadir 10 Filière SMI

2.5. EXERCICE 5 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

if (Tete->suiv == Queue) { /* liste comporte 2 elemnts */

free(Tete);
free(Queue);
*lis = 0;
}
else {
/* supprimer tete */
*lis = (*lis)->suiv;
free(Tete);

/* supprimer queue */
free(Queue);
PrecQueue->suiv = 0;
}
}

2.5 Exercice 5

Considérons une pile de réels dont les noeuds ayant la structure suivante :

typedef struct UnePile {

float valeur;
struct UnePile * suiv;
} UnePile;

1. void Empiler(UnePile **P, float val){

UnePile *elem = 0;

/* creer un nouveau element */

elem = (UnePile*)malloc(sizeof(UnePile));
if (elem == 0){
printf("Probleme allocation\n");
exit(0);
}
else {
/* initialisation */
elem->valeur = val;
/* insertion*/
if (*P==0)
elem->suiv = 0;
else elem->suiv = *P;

*P = elem;
}
}
2. Empiler(&A,a);

M. El Ansari, Faculté des Sciences, Agadir 11 Filière SMI

2.6. EXERCICE 6 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

2.6 Exercice 6
1. Donner une fonction recursive permettant de calculer le nombre d’éléments d’une liste.
Donner sa complexité.
int longueur(Liste L)
{
if (L==NULL) return 0;
else return (1+longueur(L->next));
}
T(n)= 1+T(n-1)=2+T(n-2)=n+T(0)=n.
est en O(n)
2. Donner une fonction permettant de fusionner deux listes qui sont triées par ordre croissant.
La liste résultante doit être elle même triée par ordre croissant. La fonction reçoit deux listes
triées et retourne une liste triée. Les deux listes passées en paramètres ne doivent pas être
conservées par la fonction : il est encouragé de réutiliser leurs maillons pour venir les chaı̂ner
au bon endroit dans la liste chaniée résultat.
/* A function to merge two sorted lists */
struct node *merge (struct node *p, struct node *q)
{
struct node *r=NULL,*temp;
if (p == NULL)
r = q;
else
if(q == NULL)
r = p;
else
{
if (p->data < q->data )
{
r = p;
temp = p;
p = p->link;
temp->link = NULL;
}
else
{
r = q;
temp =q;
q =q->link;
temp->link = NULL;
}
while((p!= NULL) && (q != NULL))
{
if (p->data < q->data)
{
temp->link =p;
p = p->link;
temp =temp->link;
temp->link =NULL;
}
else

M. El Ansari, Faculté des Sciences, Agadir 12 Filière SMI

2.7. EXERCICE 7 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

{
temp->link =q;
q = q->link;
temp =temp->link;
temp->link =NULL;
}
}
if (p!= NULL)
temp->link = p;
if (q != NULL)
temp->link = q;
}
return( r) ;
}

2.7 Exercice 7

Supposons que nous disposons d’une pile P d’entiers. Nous souhaitons renverser les éléments de
P en utilisant deux méthodes différentes :
1. Donner une fonction en C permettant de renverser les éléments de P en utilisant une pile
auxilaire (méthode 1).
typedef struct stack {
int data;
struct stack *next;
} STACK;

int pop(STACK **head);

int pop(STACK **head);
STACK * RenverserPileAuxilaire(STACK ** Pile)
{
STACK * p = NULL;
if (!(*Pile)) return NULL;
while (*Pile)
{
push(&p, pop(Pile));
}
return p;
}

2. Donner une fonction en C permettant de renverser les éléments de P en utilisant une file
auxilaire (méthode 2).
struct queue_node
{
struct queue_node *next;
int data;
};

struct queue

M. El Ansari, Faculté des Sciences, Agadir 13 Filière SMI

2.7. EXERCICE 7 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

{
struct queue_node *first; // Defiler
struct queue_node *last; //Enfiler
};

int enqueue(struct queue *q, const int value);

int dequeue(struct queue *q, int *value);
int pop(STACK **head);
int pop(STACK **head);

void RenverserFileAuxilaire(STACK ** Pile)

{
queue q; int x;
q.first = q.last = NULL;

while (*Pile != NULL)

enqueue(&q, pop(Pile));

while(q.first != NULL)
{
dequeue(&q, &x);
push(Pile,x);
}
}

/*------- empiler ----------*/

void push(STACK **head, int value){
/* create a new node */
STACK *node = (STACK*)malloc(sizeof(STACK));
if (node == NULL){
fputs("Error: no space available for node\n", stderr);
abort();
} else {
/* initialisation */
node->data = value;
/* insertion*/
if (*head==NULL)
node->next = NULL;
else node->next = *head;
*head = node;
}
}

/*-----------------------DEPILER ---------------*/

void push(STACK **head, int value);

{
if (*head==NULL) {/* pile est vide */
fputs("Error: stack underflow\n", stderr);
abort();

M. El Ansari, Faculté des Sciences, Agadir 14 Filière SMI

2.7. EXERCICE 7 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

} else {
/* depiler un element */
STACK *top = *head;
int value = top->data;
*head = top->next;
free(top);
return value;
}
}

/*---------- Enfiler --------------------------------*/

int enqueue(struct queue *q, const int value)

{
struct queue_node *node = (struct queue_node *)malloc(sizeof(struct
queue_node));
if (node == NULL) {
printf("probleme d’allocation memoire");
return 1;
}
node->data = value;
if (q->first == NULL) {
q->first = q->last = node;
} else {
q->last->next = node;
q->last = node;
}
node->next = NULL;
return 0;
}

/*--------------- Defiler---------------------------------------*/

int dequeue(struct queue *q, int *value)

{
if (!q->first) {
/* test si la file vide */
*value = 0;
return 1;
}
/* recuperer la valeur du noeud supprimer */
*value = q->first->data;
/* recuperer l’adresse du noeud supprimer */
struct queue_node *tmp = q->first;
if (q->first == q->last) {
q->first = q->last = NULL;
} else {
q->first = q->first->next;
}
free(tmp); /* liberation de l’esapce occupe par le noeud suprime*/

M. El Ansari, Faculté des Sciences, Agadir 15 Filière SMI

2.8. EXERCICE 8 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

return 0;
}

2.8 Exercice 8

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

typedef struct noeud{

int val;
struct noeud * suiv;
} noeud;

void afficher(noeud *l)

{
while (l)
{
printf("%d\t ", l->val);
l = l->suiv;
}

printf("\n");
}

/********************* Question 1 ********************************/

void trier(noeud **l)
{
noeud * p1, *p2;
int temp;
p1 = *l;
while (p1->suiv)
{
p2 = p1->suiv;
while (p2){
if (p1->val < p2->val)
{
temp = p1->val;
p1->val = p2->val;
p2->val = temp;
}
p2 = p2->suiv;
}
p1 = p1->suiv;
}

M. El Ansari, Faculté des Sciences, Agadir 16 Filière SMI

2.8. EXERCICE 8 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

/*************** Question 2 *************************/

void inserertrier(noeud **l, int i)
{
noeud * p = 0, *elem = 0;
elem = (noeud*) malloc(sizeof(noeud));
if (!elem) { printf("Prob alloc\n"); exit(0);}
elem->val = i;
p = *l;

if (!p) /* liste vide */

{
*l = elem;
elem->suiv = NULL;
}
else if (!p->suiv) /* liste comporte 1 element */
{
if (i>=p->val)
{
elem->suiv = p;
p = elem;
}
else {
elem->suiv = NULL;
p->suiv = elem;
}
}
else /* nombre lement > 1 */
{
while (p->suiv){
if ((i<= p->val) && (i>=p->suiv->val)){
elem->suiv = p->suiv;
p->suiv = elem;
return;
}
p = p->suiv;
}

if (p->val >= i)
{
p->suiv = elem; elem->suiv = NULL;
}
else
{
elem->suiv = *l;
*l = elem;
}
}

M. El Ansari, Faculté des Sciences, Agadir 17 Filière SMI

2.8. EXERCICE 8 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

/******************* Question 3 *********************/

int debut(noeud *l1, noeud *l2)

{
while (l1 && l2)
{
if (l1->val != l2->val) return 0;
l1 = l1->suiv; l2 = l2->suiv;
}
if (!l1) return 1; else return 0;
}

/*** ********* Question 4 ************************ *****/

int partie (noeud *l1, noeud *l2)

{
while (l2)
{

if (debut(l1,l2)) return 1;
l2 = l2->suiv;

}
return 0;
}

/* ************ *********************************** */

void inserer(noeud **l, int i)

{
noeud * elem = 0;
elem = (noeud*) malloc(sizeof(noeud));
if (!elem) { printf("Prob alloc\n"); exit(0);}
elem->val = i;
if (*l)
{
elem->suiv = *l;
*l =elem;
}
else { *l = elem; elem->suiv = NULL;}
}

/******************************************************* */

void insererfin(noeud **l, int i)

{

M. El Ansari, Faculté des Sciences, Agadir 18 Filière SMI

2.8. EXERCICE 8 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

noeud * elem = 0, *p;

elem = (noeud*) malloc(sizeof(noeud));
if (!elem) { printf("Prob alloc\n"); exit(0);}
elem->val = i;elem->suiv = NULL;

if (*l == NULL) *l = elem;

else {
p = *l;
while (p->suiv) p=p->suiv;
p->suiv = elem;
}
}

/******* Programme Test ********************* */

main()
{
int i;
noeud * L = 0;
for(i=0; i<9 ; i++)
inserer(&L, rand()%15);

afficher(L);
trier(&L);
afficher(L);

inserertrier(&L, 8);
afficher(L);

inserertrier(&L, -1);
afficher(L);

inserertrier(&L, 89);
afficher(L);

noeud *L1=0, *L2=0;

for(i=0; i< 5;i++)

{
insererfin(&L1,i);
}

for(i=-5; i<7 ;i++)

insererfin(&L2,i);

printf("L1 = "); afficher(L1);

printf("L2 = "); afficher(L2);
if (debut(L1,L2)) printf("L1 est un debut de L2\n");
else printf("L1 n’est pas un debut de L2\n");

M. El Ansari, Faculté des Sciences, Agadir 19 Filière SMI

2.9. EXERCICE 9 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

if (partie(L1,L2)) printf("L1 est une partie de L2\n");

else printf("L1 n’est pas une partie de L2\n");

2.9 Exercice 9

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

// structure arbre
typedef int element_type;
typedef struct tree_node *tree_ptr;
struct tree_node {
element_type element;
tree_ptr left;
tree_ptr right;
};

typedef tree_ptr SEARCH_TREE;

tree_ptr insert( element_type x, SEARCH_TREE T )

{
if( T == NULL )
{ // Creer et retourner un arbre compose d’un seul noeud
T = (SEARCH_TREE) malloc ( sizeof (struct tree_node) );
if( T == NULL ) {printf("Espace memoire insuffisant!!!");
exit(0);
}
else
{
T->element = x;
T->left = T->right = NULL;
}
}
else if( x <= T->element )
T->left = insert( x, T->left );
else if( x > T->element )
T->right = insert( x,T->right );
// Sinon x existe deja dans l’arbre. On va rien faire
return T; // Ne pas oublier cette ligne!!
}

M. El Ansari, Faculté des Sciences, Agadir 20 Filière SMI

2.9. EXERCICE 9 CHAPITRE 2. SOLUTION DES EXERCICES PROPOSÉS

// ***** Question 1 ************************************

tree_ptr RechercherElement(SEARCH_TREE Arbre, element_type e)

{
if (Arbre == NULL) return NULL;
if (e == Arbre->element)
return Arbre;
else if (e > Arbre->element)
return RechercherElement(Arbre->right, e);
else return RechercherElement(Arbre->left,e);
}

/**** *************** Question 2 *********** *****/

int comparer(tree_ptr a1, tree_ptr a2)

{
if (a1==NULL) return (a2 != NULL);
else { // a1!=NULL
if (a2 == NULL) return 1;
else // a2 != NULL
return ((a1->element != a2->element)||comparer(a1->left,
a2->left)||comparer(a1->right, a2->right));
}
}

/* Programme test */

main(){
tree_ptr A=NULL, B=NULL;
A = insert(4, A); A = insert(3, A); A = insert(7, A); A = insert(-2, A);
B = insert(-2, B); B = insert(3, B); B = insert(7, B); B = insert(4,
B);

if (comparer(A,B)) printf("non simlaires\n");

else printf("similaires\n");
}

M. El Ansari, Faculté des Sciences, Agadir 21 Filière SMI