Chapitre-5 : Les Fonctions & les Procédures

Chapitre-5 : Les Fonctions & les Procédures

Table des matières

1 Les fonctions & les procédures ....................................................................................................... 1
1.1 Structuration ........................................................................................................................... 1
1.2 Les paramètres d’entrés de sorties et d’entrés/sortie............................................................ 2
1.3 Les fonctions ............................................................................................................................ 3
1.4 Les Procédures ........................................................................................................................ 4
1.5 Processus d’analyse ............................................................................................................ 7
1.5.1 La décomposition en sous traitement ............................................................................. 7
1.5.2 La décomposition récursive............................................................................................. 7
1.6 Les fonctions récursives ...................................................................................................... 8
1.6.1 Fonction Factoriel ............................................................................................................ 8
1.6.2 Fonction Racine carrée .................................................................................................... 9
1.6.3 Recherche du Maximum avec une méthode récursive ................................................. 10
1.6.4 Recherche du Maximum avec la Méthode de diviser pour régner ............................... 11
2 Les algorithmes de Tri ................................................................................................................... 12
2.1 Le tri par la méthode du Min ou Max successif (Tri par sélection) ....................................... 12
2.2 Le tri par la méthode à bulles ................................................................................................ 13
2.3 Le tri par la méthode insertion .............................................................................................. 14
2.4 Le tri rapide (tri pivot) ........................................................................................................... 15
3 Les algorithmes de Recherche....................................................................................................... 17
3.1 Recherche linéaire dans un ensemble non trié ..................................................................... 17
3.2 Recherche linéaire dans un ensemble trié suivant un ordre croissant ................................. 18
3.3 Recherche par la méthode de Dichotomie............................................................................ 18
3.3.1 Utilisation de la dichotomie pour chercher le Maximum.............................................. 19

1 Les fonctions & les procédures

1.1 Structuration

La décomposition en plusieurs sous-programmes est un moyen efficace pour bien contrôler un

programme informatique (diviser pour mieux régner). Les fonctions et les procédures
permettent de décomposer un programme complexe en une série de sous-programmes plus

A.BENMAKHLOUF Page 1
 Chapitre-5 : Les Fonctions & les Procédures
simples, lesquels peuvent à leur tour être décomposés eux-mêmes en fragments plus petits, et
ainsi de suite.

Les fonctions et les procédures présentent donc un intérêt primordial dans les conceptions des
algorithmes. Ils ont comme rôles de :
 Regrouper un ensemble d’instruction dans le même algorithme afin de pouvoir y faire
appel autant de fois que nécessaire.
 Avoir un algorithme principal qui fait appel aux différents fonctions et/ou procédures
 Avoir une lisibilité et identification faciles des erreurs.

Il est inutile de connaître comment est définie une fonction ou une procédure pour y faire
appel. Par contre il est nécessaire de connaître sa déclaration (son manuel d’utilisation):
 Quel est son rôle?
 Quels sont les arguments à fournir?
 Quelles est la valeur retournée?

1.2 Les paramètres d’entrés de sorties et d’entrés/sortie

Les procédures et les fonctions peuvent nécessiter éventuellement un ou plusieurs paramètres
d’entrée ou de sortie. Ces paramètres sont des variables ou des pointeurs dont les valeurs
seront manipulées par ces fonctions.

Un paramètre d’entrée est la référence à une variable manipulée par la procédure ou la

fonction. Dans ce cas la valeur d’une variable du programme principal est copiée dans ce
paramètre.
Un paramètre de sortie est une variable dont la valeur est affectée par les instructions du
sous-programme
Un paramètre d’entrée-sortie Un paramètre peut jouer à la fois le rôle de paramètre d’entrée
et de sortie.

Dans les déclarations des fonctions ou des procédures les paramètres sont appelés
paramètres formels. Pendant l’appel de ces fonctions ou procédures dans le programme
principale (fonction principal main()), ils sont appelés paramètres effectifs. Le nom d’un
paramètre effectif peut être différent de celui du paramètre formel associé. Mais Dans
l’écriture des paramètres effectifs on doit respecter le même ordre qu’on a donné aux
paramètres formels.

A.BENMAKHLOUF Page 2
 Chapitre-5 : Les Fonctions & les Procédures
1.3 Les fonctions
Les fonctions sont des sous-programmes admettant des paramètres et retournant un seul
résultat (comme les fonctions mathématiques y=f(x,y,. . .)
 les paramètres sont en nombre fixe (n>=0)
 une fonction possède un seul type, qui est le type de la valeur retournée
 la valeur de retour est spécifiée par l'instruction « retourner (renvoyer) »
Généralement le nom d’une fonction doit être explicite: Maximum() ; Minimum()

Syntaxe en Langage C

type NomFonction (type a, type b, type c, …. )

{
Type res ;
…..
…..
Return res
}

Dans la syntaxe, on précise le type de valeur renvoyée par la fonction puis le nom de la
fonction. Les paramètres de la fonction (d’entrés, de sorties et d’entrées/sorties) sont
introduites entre parenthèses avec pour chacun d’eux son type. Dans la partie traitement de la
fonction on trouve la partie déclarative des variables locaux (variables qui vont être utilisées
seulement dans la fonction). A la fin du traitement on précise ce que cette fonction va
renvoyer une fois exécutée.

Exercice1 : Ecrire un programme C qui permet de calculer les termes U1, U2, …., U10 d’une
suite arithmétique connaissant le premier terme U0, la raison « r » et le rang « n ».

Solution :
#include <stdio.h>

int F(int rang, int raison, int terme0)

{
int U;
U=terme0+rang*raison;
return (U);
}

main(){
int U0, U, r, n;
printf("donner le terme0 ") ;
scanf("%d",&U0);
printf("donner la raison ") ;

A.BENMAKHLOUF Page 3
 Chapitre-5 : Les Fonctions & les Procédures
scanf("%d",&r);
for (n=1; n<=10; n++)
{U=F(n, r, U0);
printf("U%d = %d\n", n, U);}}
Exercice2 : Ecrire une fonction Maximum(T, n) qui permet de trouver le maximum d’un
tableau d’un certain nombre de valeurs. Ecrire un algorithme test qui appelle cette fonction.

Solution

#include <stdio.h>
int Fmax(int *T, int n)
{int Max, i;
Max=T[0];
for(i=0; i<n; i++)
{if(T[i]>Max)
Max=T[i];}
return(Max);}

main(){
int i, n, *tab;
printf("donner le nombre de valeur n = ") ;
scanf("%d",&n);
tab=(int*)malloc(n*sizeof(int));
for (i=0; i<n; i++)
{printf("tab(%d) = ", i);
scanf("%d", tab+i);}
printf("le maximum est : %d", Fmax(tab, n));}

1.4 Les Procédures

Les procédures sont des sous-programmes qui ne retournent aucun résultat. Par contre elles
admettent des paramètres d’entrés, de sorties ou d’Entrées/Sorties.

Syntaxe en langage C

void NomProcédure (type a, type b, type c, …. )

{ Type variablesLocals;
….
…..}

Exercice-1 :
Ecrire une procédure permute(a, b) qui permute les valeurs de ceux variables entiers. Ecrire
un algorithme d’essai.

A.BENMAKHLOUF Page 4
 Chapitre-5 : Les Fonctions & les Procédures

#include <stdio.h>
void permute(int *a, int *b)
{int k;
k = *a;
*a = *b;
*b = k;}

main()
{int x, y;
printf("x = ");
scanf("%d", &x);
printf("y = ");
scanf("%d", &y);
permute(&x, &y);
printf("x = %d\n", x);
printf("y = %d", y);}

Dans cette exercice nous constatons que les paramètres d’entrées de la fonction permute()
sont des pointeurs. En effet nous somme obligé dans ce cas de faire passer à la fonction les
adresse des variables et non pas les valeurs puisque nous avons choisi d’appeler la fonction
permute() avec des variables différentes que celles utilisées par la fonction elle-même.

Exercice-2 :
Ecrire une procédure permute(a, b) qui permute les valeurs de ceux variables entiers.
Ecrire une autre procédure Tri (x, y, z) qui tri dans l’ordre croissant en appelant la procédure
permute(a, b). Ecrire un algorithme d’essai.

Solution :

#include <stdio.h>
void permute(int *a, int *b){
int k;
k=*a;
*a=*b;
*b=k;}
void tri(int x, int y, int z){
if (x<y)
permute(&x,&y);
if (y<z)

A.BENMAKHLOUF Page 5
 Chapitre-5 : Les Fonctions & les Procédures
permute(&y,&z);
if (x<y)
permute(&x,&y);
printf("%d%d%d", x, y, z);}
main(){
int z1,z2,z3;
printf("donner trois valeurs\n");
scanf("%d", &z1);
scanf("%d", &z2);
scanf("%d", &z3);
tri(z1, z2, z3);}

Exercice-3 :
Créer une fonction max2(a, b) qui renvoi le maximum de deux variables:
Créer une fonction VMAX(T) qui permet trouver le maximum des éléments d’un vecteur de 4
valeurs et ceci en appelant la fonction max2().
Créer un algorithme d’essai.

Solution :

#include <stdio.h>
int Max(int a, int b){
int res;
res=a;
if(b>a)
{res=b;}
return (res);}

int VMAX(int *V){

int i, M;
for (i=0; i<=4; i++)
M=Max(Max(Max(Max(V[0], V[1]),V[2]),V[3]),V[4]);
return (M);}

main(){
int V[5], i;
for (i=0; i<=4; i++){
printf("V[%d]=", i);
scanf("%d", &V[i]);}
printf("le maximum est: %d\n", VMAX(V));}

A.BENMAKHLOUF Page 6
 Chapitre-5 : Les Fonctions & les Procédures
1.5 Processus d’analyse

1.5.1 La décomposition en sous traitement

Le processus d’analyse permet de décomposer un traitement complexe en sous traitement
« plus simples » mais différent du précédent. À leur tour, ces sous problèmes seront à leur
tour décomposés jusqu’à un niveau d’opération « élémentaires » faciles à réaliser.

1.5.2 La décomposition récursive

Dans certain cas, le sous traitement est une illustration du problème initial, mais pour un cas
« plus simple ». Par conséquent, la solution du problème s’exprime par rapport à elle-même !
On appelle ce phénomène récursivité.

Dans un raisonnement par récurrences : pour résoudre un problème complexe on appelle le

même traitement initial mais avec un cas plus simple.

Exemple de Récursivité

La factoriel de n est donnée par :

n! = 1*2*…..*(n-1)*n

n! = n*(n-1)!

A.BENMAKHLOUF Page 7
 Chapitre-5 : Les Fonctions & les Procédures
Pour calculer la valeur de n!, il suffit donc de savoir calculer (n-1)! Et ensuite de multiplier
cette valeur par n.

Le sous problème du calcul (n-1)! Est le même problème initial, mais pour un cas « plus
simple » car (n-1 < n)

1.6 Les fonctions récursives

Pendant le traitement d’une fonction nous pouvons appeler d’autres fonctions déjà déclarées
(décomposition en sous problèmes).
Nous pouvons aussi, Pendant le traitement d’une fonction, appeler la même fonction initiale
mais avec des arguments plus simples (décomposition récursive)
Une fonction récursive est une fonction qui s’appelle elle-même dans son traitement. Si la
fonction appelée n’est autre que la fonction qui appelle, on déclenche une boucle. Cette
boucle doit s’arrêter une fois arrivé au traitement élémentaire. Ce dernier va être formalisé
sous forme d’un test logique.

1.6.1 Fonction Factoriel

Ecrire l'algorithme de la fonction factorielle en employant les deux méthodes itérative et
récursive.

Résonnement itérative Résonnement récursive

#include <stdio.h> #include <stdio.h>
int fact(int n) int fact(int n)
{ {
int res, i; int res, i;
if(n==0) if(n==0)
res=1; res=1;
else else
res=1; res=n*fact(n-1);
for(i=1; i<=n; i++) return(res);}
res=res*i;
return(res);
}

main()
{
int x;
printf("x = ");
scanf("%d", &x);
printf("%d! = %d", x, fact(x));
}

Simulation: de du résonnement récursive pour N = 5

A.BENMAKHLOUF Page 8
 Chapitre-5 : Les Fonctions & les Procédures
Fact(5)=5*Fact(4)
=5*4*Fact(3)
=5*4*3*Fact(2)
=5*4*3*2*Fact(1)
=5*4*3*2*1

1.6.2 Fonction Racine carrée

La valeur de la racine carrée d'un nombre A peut-être approximée en employant la suite
récurrente d'ordre 1 suivante:

Solution :

Méthode itérative

#include <stdio.h>
float abs(float x){
if (x>0)
{return (x);}
else
{return (-x);}}
float racine(float A, float e){
float X;
X=1;
while(abs(X*X-A)>e)
X=(X+A/X)/2;
return(X);}
main(){
float Y, e;
printf("Y=");
scanf("%f", &Y);
printf("e=");
scanf("%f", &e);
printf("Racine(%f)=%f", Y, racine(Y,e));
}

Méthode récursive

La récursivité ne porte pas sur la variable principale du problème A (variable dont on cherche
la racine : A) mais la récursivité porte sur une autre variable X

#include <stdio.h>

A.BENMAKHLOUF Page 9
 Chapitre-5 : Les Fonctions & les Procédures
float abs(float x){
if (x>0)
{return (x);}
else
{return (-x);}}
float racine(float A, float e, float X){
float res;
if (abs(X*X-A) <= e)
{res=X;}
else
{res = racine(A, e, (X+A/X)/2);}
return (res);}
main(){
float y0, e, A;
printf("Y=");
scanf("%f", &A);
printf("e=");
scanf("%f", &e);
printf("Y0=");
scanf("%f", &y0);
printf("Racine(%f)=%f", A, racine(A,e,y0));}

Simulation A=2, X=1

Res = racine(2, 1.5)

2,25 – 2 = 0,25 > 0,001
Res = racine(2, 1,416)
Res = racine(2, 1,414)
|(1,414)2 – 2| = 0,0006 < 0,001

1.6.3 Recherche du Maximum avec une méthode récursive

Soit la fonction Max(a, b) qui renvoi le maximum de deux réels.

Ecrire une fonction récursive « RecMax(V, n) » qui renvoi le maximum des valeurs d’un
tableau V de dimension n. cette fonction aura pour argument les éléments du vecteur V et la
dimension n

Cette fonction récursive doit renvoyer la valeur suivante:

Solution

#include <stdio.h> main(){

#include <stdlib.h> int i, n;
int Max(int a, int b) int *T;
{

A.BENMAKHLOUF Page 10
 Chapitre-5 : Les Fonctions & les Procédures
if (a > b) printf("Donnez le nombre de valeur \n") ;
return(a); scanf("%d",&n);
else T=(int*)malloc(n*sizeof(int));
return(b); for(i=0; i<=n-1; i++){
} printf("T(%d) = ", i);
scanf("%d",&T[i]);}
int RecMax(int *V, int N){
int G; printf("le max est:%d\n", RecMax(T, n));}
if (N==2)
G=Max(V[0],V[1]);
else
G=Max(RecMax(V, N-1) ,V[N-1]);
return (G);
}

1.6.4 Recherche du Maximum avec la Méthode de diviser pour régner

Pour trouver le maximum des valeurs d’un tableau de dimension n (V(0..n-1)) en utilise la
méthode « diviser pour régner ». Cette méthode se compose de trois étapes

Diviser : diviser le tableau en deux sous-tableaux.

Régner : trouver récursivement le maximum et le minimum dans chaque demi-tableau.
Combiner : retourner le maximum des deux maximums trouvés.

Algorithme :
On suppose qu’on dispose d’une fonction Max() qui permet de trouver la maximum de deux
valeurs.
Soit les variables :
Deb : indice du premier élément du tableau
Fin : indice du dernier élément du tableau
Med : indice du milieu d tableau
Max1 : le maximum du premier demi-tableau
Max2 : le minimum du deuxième demi-tableau

#include <stdio.h> int main(){

#include <stdlib.h> int n, i, deb, fin;
int Max(int A, int B){ int *tab;
if (A > B) printf("Donnez le nombre de valeur n >= 0 ") ;
return(A); scanf("%d",&n);
else tab=(int*)malloc(n*sizeof(int));
return(B);} deb = 0;
fin = n-1;
int FMax(int *v, int deb, int fin){ for(i=0;i<n;i++){
int mid, max1, max2; printf("tab(%d) = ", i) ;
if((fin - deb) <=1) scanf("%d",tab+i);}
return(Max(v[fin], v[deb])); printf("Le max est %d\n",FMax(tab, deb, fin));}
else{
mid=(deb + fin)/2;
A.BENMAKHLOUF Page 11
 Chapitre-5 : Les Fonctions & les Procédures
max1=FMax(v, deb, mid);
max2=FMax(v, mid+1, fin);
return(Max(max1, max2));}}

2 Les algorithmes de Tri

Les tableaux permettent de stocker plusieurs éléments de même type au sein d'une seule
entité. Trier un tableau c'est donc ranger les éléments d'un tableau en ordre croissant ou
décroissant.

Il existe plusieurs méthodes de tri qui se différencient par leur complexité d'exécution et leur
complexité de compréhension pour le programmeur.

 Nous exposons dans ce cours trois méthodes :

 le tri par minimum (maximum) successif (tri de selection)

 Le tri à bulles

 Le tri par insertion

Dans les deux premières méthodes de tri, on doit utiliser une procédure qui permet d'échanger
(de permuter) la valeur de deux variables.

void permute(int *a, int *b)

{
int k;
k=*a;
*a=*b;
*b=k;
}

2.1 Le tri par la méthode du Min ou Max successif (Tri par sélection)
Cette méthode consiste à parcourir le tableau de gauche à droite, on cherche le plus petit
élément puis on le positionne dans l’indice i du tableau. On recommence la même opération
pour le sous-tableau de droite qui commence par l’indice i+1.

plus généralement : Pour trier le sous-tableau t[i  n-1] il suffit de positionner au rang i le
plus grand élément de ce sous-tableau et de trier le sous-tableau t[i+1  n-1]

Par exemple, pour trier [221, 215, 130, 163, 147, 120] suivant un ordre croissant, on va avoir
les boucles suivantes :

A.BENMAKHLOUF Page 12
 Chapitre-5 : Les Fonctions & les Procédures

Il nous faut donc :

- une fonction poxmax() qui soit capable de renvoyer l’indice pmax du plus grand
élément d'un tableau à partir d'un certain r.
- Une procédure Tri() qui appelle la fonction posmax() pour trouver l’indice pmax
correspondant au maximum puis permute l’élément pmax avec l’élément i.

int posmax(int *T, int n, int r){ void Tri(int *V, int n){
int pmax, Max, i; int rang, i, indexmax, k;
Max=T[r]; for(i=0; i<n; i++)
pmax=r; {
for(i=r; i<n; i++) indexmax=posmax(V, n, i);
{ if(V[i]!=V[indexmax])
if(T[i]>Max) permute(V+i, V+indexmax);
{Max=T[i]; }}
pmax=i;}
}
return(pmax);}

2.2 Le tri par la méthode à bulles

Cette méthode consiste à parcourir le tableau du début à la fin et en échangeant tout couple
d'éléments consécutifs non ordonnés jusqu'à ce que le minimum (maximum) se case à droite
(à gauche). On recommence la même opération mais cette fois avec le tableau sans les
éléments déjà casés.

Par exemple, pour trier [130, 156, 213, 230, 300] suivant un ordre décroissant, on va avoir les
boucles suivantes :

A.BENMAKHLOUF Page 13
 Chapitre-5 : Les Fonctions & les Procédures

i=2 ; ………….

Avec cette méthode on utilisera deux boucles imbriquées.

void Tri(int *T, int n) main(){

{ int i, n, *tab;
int i, k, j; printf("donner le nombre de valeur n = ") ;
for(j=0; j<n-1; j++) scanf("%d",&n);
{ tab=(int*)malloc(n*sizeof(int));
for(i=0; i<n-1-j; i++) for (i=0; i<n; i++)
{ {printf("tab(%d) = ", i);
if(T[i]<T[i+1]) scanf("%d", tab+i);}
permute(T+i, T+i+1); Tri(tab, n);
} for (i=0; i<n; i++)
}
printf("tab(%d) = %d\n", i, *(tab+i));}
}

2.3 Le tri par la méthode insertion

Ce tri s’inspire d’un processus naturel utilisé dans le tri des cartes qu’un possédé dans sa
main, le joueur prend chaque carte et l’insère à sa place en décalant les autres. Concrètement
cette méthode consiste à effectuer des insertions successives de chaque élément T[i] du
tableau dans le sous tableau T[i0  i-1]. Donc ce tri utilise le processus élémentaire
d’insertion d’un élément dans une liste des valeurs. Ce tri n’est pas très performant pour un
grand ensemble de données.

Par exemple, pour trier [12, 34, 13, 9, 15, 0] suivant un ordre décroissant, on va avoir les
boucles suivantes :

A.BENMAKHLOUF Page 14
 Chapitre-5 : Les Fonctions & les Procédures

La fonction qui permet faire ce tri est la suivante :

void Tri_Insert(int *T, int n){

int e, k, i;
for(i=1; i<n; i++)
{
e=T[i];
for(k=i; k>0 && e>T[k-1]; k--)
T[k]=T[k-1];
T[k]=e;
}
}

2.4 Le tri rapide (tri pivot)

C'est l’un des tris les plus rapides, et les plus utilisés. La méthode est constituée de deux
méthodes.

Placer un élément du tableau (appelé pivot) à sa place définitive, en permutant tous les
éléments de telle sorte de placer toutes les valeurs inférieures au pivot à sa gauche et placer
ceux qui sont supérieurs à sa droite. Cette opération s'appelle le partitionnement.

Pour chacun des sous-tableaux de gauche et de droite, on applique par récurrence le même
traitement avec un nouveau pivot, jusqu'à ce que l'ensemble des éléments soit trié.

A.BENMAKHLOUF Page 15
 Chapitre-5 : Les Fonctions & les Procédures
- L’exemple ci-dessous montre l’opération de partitionnement avec le pivot V[0].

- Les appelles récursive de l’opération de partitionnement dans les sous tables se sont
représenté par la figure ci-dessous.

A.BENMAKHLOUF Page 16
 Chapitre-5 : Les Fonctions & les Procédures

void perm(int *a, int *b)

{
int k;
k=*a;
*a=*b;
*b=k;
}
int pivot(int *T, int deb, int fin)
{
int pv=deb;
int j=deb, i;
for(i=deb+1; i<=fin;i++){
if(T[i]<T[pv])
{
j++;
perm(T+i, T+j);
}
}
perm(T+j, T+deb);
return j;
}
void tri(int *T, int deb, int fin)
{
int pv;
if(deb<fin)
{
pv=pivot(T, deb, fin);
tri(T, deb, pv-1);
tri(T, pv+1, fin);
}
}

3 Les algorithmes de Recherche

3.1 Recherche linéaire dans un ensemble non trié
On procède par une recherche linéaire on parcourant le tableau et lorsque qu’on trouve le
nombre recherché (T(i)=X) on renvoi l’indice correspondant. Si on parcourt tous le tableau
sans trouver la valeur recherchée on déclare que le nombre n’existe pas. La procédure écrite
en C qui permet de faire cette recherche est :

void Recherche(int *T, int n, int x){

A.BENMAKHLOUF Page 17
 Chapitre-5 : Les Fonctions & les Procédures
int i;
i=0;
while(i<n && x!=T[i])
i++;
if(x==T[i])
printf("la valeur est trouvee a i = %d", i);
else
printf("la valeur est introuvable");
}
3.2 Recherche linéaire dans un ensemble trié suivant un ordre croissant
On procède par une recherche linéaire on parcourant le tableau et tant que l’élément du
tableau est inférieur au nombre recherché (t(i) < X) on continu la recherche. Si on parcourt
tous le tableau sans trouver la valeur recherchée on déclare que le nombre n’existe pas. La
procédure écrite en C qui permet de faire cette recherche est :

void Rech(int *T, int n, int x){

int i;
i=0;
while(i<n && x>T[i])
i++;
if(x==T[i])
printf("la valeur est trouvee a i = %d", i);
else
printf("la valeur est introuvable");
}

3.3 Recherche par la méthode de Dichotomie

Dès que le nombre de données devient important, la recherche séquentielle demande plus de
temps d’exécution. Il faut donc le temps de traitement en utilisant des algorithmes plus
performants, comme la méthode dichotomique. Cet algorithme est basé sur le principe de
« diviser pour résoudre ». On divise l’ensemble de recherche en deux sous-ensembles égaux.
On détermine ensuite dans quel sous-ensemble doit se trouver la valeur recherchée. Puis on
poursuit la recherche d’une manière récursive dans les sous-ensembles jusqu’à ce qu’on
trouve la valeur recherché ou on arrive à un sous-intervalle où la borne inférieure coïncide
avec la borne supérieure et donc on conclut que la valeur n’existe pas dans cette ensemble.
La procédure récursive qui permet d’utiliser cette méthode pour rechercher une valeur dans un
tableau d’entier est donné par :

void Rech_Dico(int *T, int deb, int fin, int x)

{
int i, mid, z;
if(deb>fin)
printf("valeur introuvable");
else {

A.BENMAKHLOUF Page 18
 Chapitre-5 : Les Fonctions & les Procédures
mid=(deb+fin)/2;
if(T[mid]==x)
printf("valeur trouvee a %d", mid);
else
{
if(x<T[mid])
fin=mid;
else
deb=mid+1;
Rech_Dico(T, deb, fin, x);
}
}
}

La version itérative est donnée par la procédure suivante :

void Rech_Iterra(int *T, int deb, int fin, int x)

{
int i, n, mid;
n=fin;
mid=(deb+fin)/2;
while(T[mid]!=x && deb<fin)
{
if(x<T[mid])
fin=mid;
else
deb=mid+1;
mid=(deb+fin)/2;
}
if(T[mid]==x)
printf("la valeur est trouvee a i = %d", mid);
else
printf("la valeur non trouvable");
}

3.3.1 Utilisation de la dichotomie pour chercher le Maximum

Cette méthode est déjà exposée dans le paragraphe 7-6-1-4.

A.BENMAKHLOUF Page 19