Guitari Exercices

Algorithmique et
Structures de Données
Travaux dirigés
Ramzi Guetari
Travaux Dirigés - Algorithmique et Structures de Données
© Ramzi GUETARI Page 2

Série d'exercices numéro 1
Algorithmes
itératifs
Ramzi Guetari

EXERCICE 1 : Complexité de séquences itératives
Déterminer (en fonction de n à O ( ) près) la complexité en nombre « d’opérations » de chaque

séquence :
Séq-1 : FOR i ← 1 TO N DO Séq-6 : i ← 1

Opération ; FOR j ← 1 TO n DO
END-FOR i ← 2*i
END-FOR
Séq-2 : FOR i ← 1 TO N DO FOR j ← 1 TO i DO

Opération;
FOR j ← 1 TO i DO END-FOR
Opération ;
END-FOR
Séq-7 : i ← 1
END-FOR
FOR k ← 1 TO n DO
i ← 2*i
Séq-3 : i ← 1
WHILE ( i < N) DO
FOR L ← 1 TO i DO
i ← 2*i FOR m ← 1 TO k DO
Opération ; Opération ;
END-FOR
END-WHILE
END-FOR
END-FOR
Séq-4 : FOR i ← 1 TO N DO
J ← 1
Séq-8 : FOR k ← 1 TO n DO
WHILE (J < N ) DO
i ← 1
J ← 2 * J
Opération;
END-WHILE FOR j ← 1 TO k DO
i ← 2*i
END-FOR END-FOR
FOR j ← 1 TO i DO
Séq-5 : i ← 1 Opération
END-FOR
WHILE ( i < N ) DO
END-FOR
i ← 2 * i
FOR j ← 1 TO i DO
Opération;
END-FOR
END-WHILE

EXERCICE 2 : Recherche du maximum
Calculer la complexité des fragments de code suivants :
SEQ-1 :
i ← n
s ← 0
WHILE (i > 0) DO
j ← 2 * i
WHILE (j > 1) DO
s ← s + (j - i) * (s + 1)
j ← j - 1
END-WHILE
i ← i div 2
END-WHILE
SEQ-2 :
P ← 1
FOR I ← 1 TO n DO
J ← 1
K ← 1
WHILE (K <= n) DO
P ← P * (K + J)
K ← K + 1
IF (K > n) THEN
J ← J + 1
IF (J <= n) THEN
K ← 1
END-IF
END-IF
END-WHILE
END-FOR

EXERCICE 3 : Recherche du maximum
1. Concevoir un algorithme de recherche du maximum dans un ensemble à n éléments

2. Quelle est la complexité de votre algorithme en nombre de comparaisons ?
3. Montrer qu'il est optimal.
EXERCICE 4 : Recherche du maximum et du minimum
Nous supposons ici que l'ensemble considéré ne contient pas deux fois la même valeur.
1. Proposer un algorithme naïf de recherche du maximum et du minimum d'un ensemble de

n éléments.
2. Quelle est sa complexité en nombre de comparaisons ?
3. Proposer un algorithme plus efficace.
Indication : dans une première phase les éléments sont comparés par paire.
EXERCICE 5 : Recherche du deuxième plus grand élément
Nous supposons ici que l'ensemble considéré ne contient pas deux fois la même valeur.
1. Proposer un algorithme simple de recherche du deuxième plus grand élément.

3. Réécrire l’algorithme de recherche du maximum sous la forme d'un tournoi de tennis. Il
n'est pas nécessaire de formaliser l'algorithme ici, une figure explicative suffit.
4. Dans combien de comparaisons, le deuxième plus grand élément de l'ensemble s’est
rendu compte qu’il est le plus petit des deux éléments comparés ?
5. Proposer un nouvel algorithme de recherche du deuxième plus grand élément.
EXERCICE 6 : Motif 1D
Etant donnée un tableau entier A de taille N et un tableau entier F de taille U. On suppose que
U est inférieur à N.
1. Ecrire un algorithme naïf pour chercher les sous-tableaux F de A égaux au tableau F.
L’algorithme doit afficher la position début à laquelle le tableau F est trouvé.
2. Estimer sa complexité en fonction de N et U

EXERCICE 7 : Motif 2D
Etant donnée une matrice entière A de dimension N × M et une matrice entière F de

dimension U × V. On suppose que U est inférieur à N et V est inférieur à M.
1. Ecrire un algorithme pour chercher les sous-matrices de A égales à la matrice F.
L’algorithme doit afficher la position début à laquelle une matrice est trouvée.
2. Estimer sa complexité en fonction de N, M, U et V
Exemple :
Matrice A Matrice F La matrice F existe deux fois dans la

matrice A : une à la position (0,0) et
1 5 10 3 7 1 5 10 l’autre à la position (2,1). Attention, ceci
5 10 15 4 8 5 10 15 n’est qu’un exemple, il faut écrire
12 1 5 10 3 l’algorithme dans le cas général
6 5 10 15 7
4 6 13 20 9


Récursivité
Ramzi Guetari

EXERCICE 1 : Longueur d'une chaîne de caractères
Soit une chaîne de caractères terminée par le caractère ‘\0’.

1. Ecrire un algorithme récursif permettant de déterminer sa longueur.
2. Estimer sa complexité.
EXERCICE 2 : Maximum dans un tableau
Soit un tableau X de N entiers.

1. Ecrire une fonction récursive simple permettant de déterminer le maximum du tableau.
EXERCICE 3 : Vérification de l'ordre d'un tableau
Un tableau X est trié par ordre croissant si X [i] ≤ X [i + 1], ∀ i

1. Elaborer un algorithme récursif permettant de vérifier qu’un tableau X est trié ou non
2. Estimer sa complexité
EXERCICE 4 : Rendre récursive la fonction somme suivante :
int somme (int* x, int n) {

int i, s ;
for (i = 0; i < n ; i++)
s += x[i];
return s;
}
EXERCICE 5 : Conversion binaire
Pour convertir un nombre entier positif N de la base décimale à la base binaire, il faut opérer
par des divisions successives du nombre N par 2.
Les restes des divisions constituent la
représentation binaire. Binaire (13) 1101
1. Ecrire une fonction récursive « Binaire »
permettant d’imprimer à l’écran la
représentation binaire d’un nombre N (voir exemple en face).
2. Donner la formule récurrente exprimant sa complexité en nombre de divisions. Estimer
cette complexité.

EXERCICE 6 : Palindrome
Un mot est un palindrome si on peut le lire dans les deux sens de gauche à droite et de droite à
gauche. Exemple : KAYAK est un palindrome.
1. Ecrire une fonction récursive permettant de vérifier si un mot est ou non un palindrome.
Elle doit renvoyer 1 ou 0.
2. Estimer sa complexité en nombre d’appels récursifs en fonction de la longueur du mot.
EXERCICE 7 : Multiplication récursive
La multiplication de deux entiers peut être réalisée à l’aide d’adition seulement.

1. Elaborer un algorithme récursif permettant de multiplier deux entiers
EXERCICE 8 : Division récursive
La division de deux entiers positifs peut être réalisée à l’aide de soustraction seulement.
1. Elaborer un algorithme récursif permettant de diviser un entier a par un entier b
EXERCICE 9 : Suite de Fibonacci
La suite de Fibonacci est définie comme suit :
 1 ⇔0≤n<2
un = 
u n −1 + u n − 2 sinon
1. Ecrire un algorithme récursif calculant Fibonacci (n)
2. Déterminer sa complexité
3. Ecrire un algorithme récursif qui calcule, pour tout n > 0, le couple (Fibonacci (n),
Fibonacci (n -1)).
4. Utiliser l'algorithme précédent pour écrire un nouvel algorithme calculant Fibonacci (n).
5. Qu'elle est la complexité (en nombre d'additions) de cet algorithme ?
6. En utilisant un tableau pour y stocker les termes calculés, proposer un meilleur
algorithme. Estimer sa complexité au meilleur, en moyenne et au pire.

EXERCICE 10 :
Soit la suite définie par :
 1 ⇔0≤n<2
un = 
2 × u n −1 + u n − 2 sinon
1. Ecrire un algorithme récursif permettant de calculer le nème terme de la suite.

EXERCICE 11 : Etiquetage de composantes connexes (1D)
Soit un tableau d’entiers contenant des valeurs 0 ou bien 1. On appelle composante connexe
une suite contigüe de nombres égaux à 1. On voudrait changer la valeur de chaque
composante connexe de telle sorte que la première composante ait la valeur 2 la deuxième ait
la valeur 3, la 3ème ait la valeur 4 et ainsi de suite. Réaliser deux fonctions :
1. la première fonction n’est pas récursive et a pour rôle de chercher la position d’un 1 dans
un tableau
2. la deuxième fonction est récursive. Elle reçoit la position d’un 1 dans une séquence et
propage une valeur x à toutes les valeurs 1 de la composante connexe.
EXERCICE 12 : Etiquetage de composantes connexes
Soit une image binaire représentée dans une matrice à 2 dimensions. Les éléments m[i][j] sont
dits pixels et sont égaux soit à 0 soit à 1.
Chaque groupement de pixels égaux à 1 et
connectés entre eux forment une
composante connexe (Figure). L’objectif est
de donner une valeur différente de 1 à
chaque composante connexe (2 puis 3 puis 4
etc.).
Image binaire Image étiquetée
1. Ecrire un algorithme récursif
« propager » permettant de partir d’un point (i, j) situé à l’intérieur d’une composante
connexe et de propager une étiquette T à tous les pixels situés à l’intérieur de la
composante.
3. Ecrire un algorithme « etiqueter » permettant d’affecter une étiquette différente à chaque
composante connexe.

EXERCICE 13 : Triangle de Pascal
Le triangle de Pascal est défini comme suit : les éléments de la première 1

colonne et ceux de la diagonale sont égaux à 1. Les autres éléments sont 1 1
obtenus en additionnant l’élément du dessus à son voisin gauche. 1 2 1
Exemple en face. Ecrire une fonction récursive permettant de générer un
1 3 3 1
triangle de Pascal de taille N. Estimer sa complexité en nombre d’appels
1 4 6 4 1
récursifs.
EXERCICE 14 :
Calculer la complexité suivante :
int x ;
int foo (int i, int j, int k) {

if (k + j == i)
return ((i - j) div k) + 1;
x = foo (i, j + 1, k - 2);
foo (i + 1, j + x, k - 2)
}
CORRECTION
Exercise 14 : T (i, j, k) = O (2k+j-i )


Diviser pour
régner
Ramzi Guetari

EXERCICE 1 : Maximum d'un tableau
Etant donné un tableau X composé de N éléments entiers. On voudrait déterminer son

maximum par un algorithme récursif basé sur le paradigme « diviser pour régner » :
1. En considérant que le maximum est le plus grand entre le dernier terme et le maximum
des (n-1) premiers termes. Estimer sa complexité.
2. En considérant que le maximum est le plus grand entre les maximums des deux moitiés
du tableau. Estimer sa complexité.
EXERCICE 2 : Recherche binaire récursive
Soit X un tableau composé de N entiers ordonnés par ordre croissant et Y un entier.

1. Elaborer un algorithme récursif permettant de trouver la position de Y dans X en opérant
selon le paradigme « diviser pour régner ».
EXERCICE 3 : Recherche récursive du maximum d'une fonction
Soit une fonction à une dimension définie par N échantillons

équidistants se trouvant dans un tableau X. On suppose que la
fonction est unimodale (croissante puis décroissante) (Voir figure).
On voudrait déterminer l’échantillon qui donne sa valeur
maximale. Ecrire un algorithme récursif permettant de déterminer
l’élément du tableau X contenant l’échantillon maximal selon le
paradigme « diviser pour régner ». Estimer sa complexité.
EXERCICE 4 : Maximum d'une matrice carré
Soit une matrice entière carrée T d’ordre N × N avec N = 2k

1. Ecrire un algorithme récursif basé sur le paradigme « diviser pour régner » permettant de
déterminer le maximum de la matrice T. L’algorithme doit procéder par la division de T
en quatre sous-matrices d’ordre (N/2 × N/2) chacune. Pour cela adopter le prototype
suivant pour l’algorithme : Maximum (T, a, b, N) avec : a : début de l’indice des lignes,
b : début de l’indice des colonnes, N : le nombre de lignes et le nombre de colonnes. Et
supposer que vous avez à votre disposition une fonction Sup (x1, x2, x3, x4) qui vous
retourne le maximum des 4 paramètres.
2. Quelle est la formule de récurrence donnant sa complexité. Expliquer.
3. Estimer cette complexité ?

Graphes et
Arbres
Ramzi Guetari

EXERCICE 1 : Liste et Matrice d'adjacence
1. Donner une représentation du graphe ci-dessus au moyen d’une liste d’adjacence, puis au
moyen d’une matrice d’adjacence.
2. Donner une représentation du même graphe en matrices d’incidence comme celles vues
dans le cours. Quel problème se pose ici ?
3. Donner une seule matrice d’incidence représentant ce graphe, proposer pour cela une
extension de la définition vue dans le cours.
EXERCICE 2 : Matrice d'incidence
Proposer un algorithme de construction de la matrice d'incidence à partir de la liste

d'adjacence d'un graphe, puis à partir de sa matrice d'adjacence.
EXERCICE 3 : Recherche de chemin
Etant donné un graphe orienté acyclique (c’est un arbre) représenté par sa matrice d’adjacence
7 6
0 1 2 3 4 5

Un graphe est un ensemble de nœuds (ou sommets) et de relations (ou arcs) entre ces nœuds.
Le graphe donné en exemple a pour nœuds: 0,1,2,3,4,5,6,7 et 8. On se propose de chercher
tous les chemins partant d’un sommet X pour arriver à un sommet Y sans passer plus d’une
fois par un même sommet.
Par exemple les chemins allant de 0 à 5 sont au 0 1 2 3 4 5 6 7 8
nombre de 4 : 0 1 2 3 4 5 , 0 1 2 8 3 4 5, 0 2 3 0 0 1 1 0 0 0 0 0 0
4 5, 0 2 8 3 4 5 1 0 0 1 0 0 0 0 0 0
Le graphe est représenté par une matrice carrée 2 0 0 0 1 0 0 0 0 0
telle que G (i, j) = 1 s’il existe un arc de i à j et 0 3 0 0 0 0 1 0 0 0 0
sinon. La matrice ci-contre représente l’exemple 4 0 0 0 0 0 1 1 0 0
de graphe ci-dessus. 5 0 0 0 0 0 0 0 0 0
6 0 0 0 0 0 0 0 1 0
S’inspirer de l’algorithme général vu en cours de 7 0 1 0 0 0 0 0 0 0
parcours d’un graphe en profondeur et écrire une 0 0 0 1 0 0 0 0 0
8
fonction en C pour trouver tous les chemins
menant d’un sommet X à un sommet Y.
EXERCICE 4 : Marquage topologique d’un graphe orienté
Soit un graphe G orienté acyclique (ne contenant pas de cycle) composé de N sommets et
représenté par une matrice G à deux dimensions N × N, G (i, j) = 0 s’il n’existe pas d’arc
reliant i à j et si G (i, j) = 1 s’il existe un arc allant de i à j. On voudrait marquer (donner un
numéro) les sommets du graphe avec des nombres entiers positifs de telle sorte que la marque
d’un sommet soit strictement inférieure à celles de tous ses successeurs (voir exemple). Un tel
marquage est dit « topologique ».
E 7
B 3
A 1
C 5
F 6
G 2
D 9
H 8
I 4
On peut remarquer que les sommets qui n’ont pas de prédécesseurs (sommets A et G) doivent
avoir les entiers les plus petits (marque 1 et 2). Si maintenant, on ignore les sommets auxquels
on vient de donner des numéros ainsi que les arcs qui partent de ces sommets, les sommets B ,
C et I n’ont plus de prédécesseurs et doivent recevoir les marques suivantes 4, 5 et 6. Et ainsi
de suite, on répète le processus pour marquer tous les sommets. La marque des sommets sera
mise dans un tableau marque (0..N-1). Cet algorithme assez simple de marquage topologique
ne s’applique qu’à un graphe ayant plusieurs sommets sans prédécesseur. La propriété qui est
à la base de cet algorithme est la suivante : les sommets ne possédant aucun prédécesseur
doivent avoir les numéros les plus « bas » disponibles.

1. Sachant que le graphe est représenté par une matrice carrée G(0..N-1,0..N-1), et que
certains sommets ont été marqués (marque(i) > 0), écrire une fonction « start » qui
renvoie vrai si un sommet j n’a aucun prédécesseur non marqué ?
2. Ecrire une fonction « marquer » pour marquer les sommets du graphe d’une manière
topologique.
EXERCICE 5 : Recherche de chemin dans un graphe acyclique
Etant donné un graphe orienté acyclique (c’est un arbre) représenté par sa matrice d’adjacence
G (G (i, j) = 1 s’il existe un arc de i à j), reprendre l’algorithme de parcours en profondeur, ci-
dessous, et le modifier pour déterminer tous les chemins menant du sommet x au sommet y.
PROCEDURE Profondeur(Graphe A)
SI A n’est pas réduit à une feuille ALORS
POUR tous les fils u de racine(A) FAIRE
Profondeur(u)
FIN-POUR
FIN-SI
FIN

Arbres Binaires
Ramzi Guetari

EXERCICE 1 : Hauteur d'un arbre enraciné
La hauteur d’un arbre est la plus grande profondeur que peut avoir un nœud quelconque de
l’arbre. Etant donné un arbre représenté par chaînage. Ecrire une fonction permettant de
déterminer la hauteur de l’arbre G. Proposer une solution récursive.
EXERCICE 2 : Maximum d'un arbre binaire
Etant donné un arbre binaire composé de N nœuds. On

struct node {
suppose que l’arbre est équilibré. Chaque nœud contient int val ;
une valeur val, un pointeur left vers le fils gauche et struct node *left ;
un pointeur right vers le fils droit. La racine est struct node *right;
pointée par un pointeur « root ». };
1. Ecrire un algorithme récursif basé sur le paradigme struct arbre {

« diviser-pour-régner » permettant de déterminer la struct node *root ;
} ;
valeur maximale se trouvant dans l’arbre.
3. Etant donné un tableau de N entiers complètements distincts. Ecrire une fonction
« construire » permettant de construire un arbre binaire de recherche en y plaçant les
éléments du tableau.
EXERCICE 3 : Vérification d'un arbre binaire de recherche
Etant donné un arbre binaire contenant N nœuds. Chaque nœud contient une valeur X, un
pointeur G vers le fils gauche et un pointeur D vers le fils droit. Dans cet exercice, utiliser les
définitions d’un nœud et d’un arbre données en encadré.
1. Décrire les différents types de parcours d’un arbre enraciné ?
2. Ecrire un programme (en C) pour vérifier si un arbre enraciné A est ou non un arbre
binaire de recherche. Expliquer votre méthode et préciser le type de parcours choisi.
3. Déterminer sa complexité.
EXERCICE 4 : Evaluation d'une expression
Soit un arbre binaire où chaque nœud contient soit

+
une valeur numérique soit un opérateur arithmétique
binaire (+ , - , * , /). L’arbre ci-contre est un exemple * /
qui représente l’expression :
3 * (10 + 13) + 10 /(18 − 23) . 3 + 10 -
On voudrait élaborer un algorithme pour calculer la
valeur d’une expression représentée par un arbre
10 13 18 23
binaire.
1. Vérifier si un arbre A est ou non complet.

2. Ecrire en C une fonction « Expression » permettant

struct node {
de calculer la valeur d’une expression représentée int Value ;
par un arbre A (On suppose que l’arbre A est déjà char Operator;
construit) et de retourner sa valeur. Il faut utiliser les struct node *left ;
structures de données présentées en encadré. Le struct node *right;
};
prototype de la fonction doit être :
float Expression ( struct tree*A) struct tree {
struct node *root ;
3. Ecrire une fonction void display (tree* A) } ;
permettant d’afficher en notation parenthésée
l’expression représentée par l’arbre A.
Valeur: contient une valeur entière si le nœud est terminal.

Operateur : contient un caractère parmi : ‘+’, ‘-‘, ‘*’, ‘/’ si le nœud n’est pas terminal.
Un nœud est terminal si ses deux fils sont nuls. Sachant que tous les opérateurs sont binaires,
chaque nœud admet ou bien 0 fils ou bien 2 fils.
EXERCICE 5 : Suppression d'un élément d'un ABR
On se propose d’écrire une fonction permettant de supprimer un élément dans un arbre binaire
de recherche. Pour cela, on vous demande d’écrire les fonctions suivantes :
4. search : permettant de chercher X dans un arbre A et de retourner, si X est trouvé, un
pointeur sur le nœud et un pointeur sur son père. Si l’élément est trouvé dans la racine de
l’arbre, le pointeur sur le père sera nul.
5. del_min : localise l’élément minimal d’un sous-arbre, le supprime de l’arbre et retourne
sa valeur.
6. delete_node : détruit dans un arbre A, un nœud identifié par un pointeur et un pointeur
sur son père.
7. delete : supprime une valeur X dans un arbre binaire de recherche A.
EXERCICE 6 : Dénombrement sur les arbres binaires
Soit un arbre binaire non vide avec : n le nombre de nœuds, f le nombre de feuilles et h sa
hauteur.
1. Quelle est la hauteur maximale d'un arbre à n nœuds ?
2. Déterminer le nombre maximal de feuilles d'un arbre de hauteur h. Indication :
commencer par déterminer une relation de récurrence donnant f.
3. Quel est le nombre maximal de nœuds d'un arbre de hauteur h ?
4. Quelle est la hauteur minimale d'un arbre de n nœuds ?

5. Montrer que le nombre de branches vides (nombre de fils gauches et de fils droits vides)
d'un arbre à n nœuds est égal à n + 1. (Indication : on distinguera les nœuds ayant zéro,
un et deux fils).
6. Montrer que le nombre de feuilles est inférieur ou égal à (n + 1) / 2 , et qu'il y a égalité si
et seulement si chaque nœud de l'arbre est soit une feuille, soit a deux fils.
7. Montrer que le nombre de feuilles d'un arbre est égal au nombre de nœuds de degré deux,
plus un.
EXERCICE 7 : Dictionnaire
On voudrait écrire un vérificateur

d’orthographe à l’aide d’un Langage
dictionnaire implémenté sous la
forme d’un arbre binaire de Algorithme Programme
recherche tel que chaque nœud
contient un mot du dictionnaire Ordinateur Récursif
et le mot contenu dans un nœud
père est supérieur au mot contenu dans le nœud du fils gauche et inférieur au mot contenu
dans le nœud du fils droit (voir exemple). On suppose que la longueur d’un mot ne dépasse
pas 20 caractères.
1. Définir les structures de données (« nœud » et « Dictionnaire ») nécessaires pour
l’implémentation d’un dictionnaire sous la forme chaînée.
2. Vérifier que l’arbre DICO est un arbre binaire de recherche
3. Ecrire une fonction « Ajouter » permettant d’ajouter un mot dans un dictionnaire DICO.
4. Ecrire une fonction « Existe » permettant de vérifier si un mot donné MOT existe ou non
dans un dictionnaire DICO. (Vous pouvez utiliser la fonction « strcmp » pour comparer
deux mots).
5. Ecrire une fonction « Imprimer » permettant d’imprimer par ordre alphabétique tous les
mots du dictionnaire DICO.
6. Sachant que le dictionnaire contient N mots. Quelle sont les complexités au pire et au
meilleur en nombre de comparaisons de mots de la fonction « Existe ». Quand est-ce
qu’on obtient la complexité au meilleur ?
7. Ecrire une fonction pour sortir le premier mot du dictionnaire DICO
EXERCICE 7 : Suppression du plus petit élément d'un ABR
Etant donné un arbre binaire de recherche A. Chaque nœud contient : val : une valeur entière,
left : un pointeur sur le fils gauche et right : un pointeur sur le fils droit. La structure

« tree » contient un seul pointeur « root » pointant sur le premier nœud de l’arbre (voir
encadré exercice 2).
1. Ecrire une fonction « int Count (tree* A) » permettant de compter et de retourner le
nombre de nœuds (non null) se trouvant dans l’arbre.
2. Ecrire une fonction « void delete (tree* A) » permettant de supprimer le nœud
contenant la plus petite valeur. Quelle est sa complexité au pire, au meilleur et moyenne ?

Guitari Exercices

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Guitari Exercices

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique et

© Ramzi GUETARI Page 2

Série d'exercices numéro 1

© Ramzi GUETARI Page 3

EXERCICE 1 : Complexité de séquences itératives

Déterminer (en fonction de n à O ( ) près) la complexité en nombre « d’opérations » de chaque

Séq-1 : FOR i ← 1 TO N DO Séq-6 : i ← 1

Séq-2 : FOR i ← 1 TO N DO FOR j ← 1 TO i DO

© Ramzi GUETARI Page 4

EXERCICE 2 : Recherche du maximum

Calculer la complexité des fragments de code suivants :

© Ramzi GUETARI Page 5

EXERCICE 3 : Recherche du maximum

1. Concevoir un algorithme de recherche du maximum dans un ensemble à n éléments

EXERCICE 4 : Recherche du maximum et du minimum

1. Proposer un algorithme naïf de recherche du maximum et du minimum d'un ensemble de

EXERCICE 5 : Recherche du deuxième plus grand élément

1. Proposer un algorithme simple de recherche du deuxième plus grand élément.

© Ramzi GUETARI Page 6

Etant donnée une matrice entière A de dimension N × M et une matrice entière F de

Matrice A Matrice F La matrice F existe deux fois dans la

© Ramzi GUETARI Page 7

© Ramzi GUETARI Page 8

Série d'exercices numéro 2

© Ramzi GUETARI Page 9

EXERCICE 1 : Longueur d'une chaîne de caractères

Soit une chaîne de caractères terminée par le caractère ‘\0’.

EXERCICE 2 : Maximum dans un tableau

Soit un tableau X de N entiers.

EXERCICE 3 : Vérification de l'ordre d'un tableau

Un tableau X est trié par ordre croissant si X [i] ≤ X [i + 1], ∀ i

EXERCICE 4 : Rendre récursive la fonction somme suivante :

int somme (int* x, int n) {

EXERCICE 5 : Conversion binaire

© Ramzi GUETARI Page 10

EXERCICE 7 : Multiplication récursive

La multiplication de deux entiers peut être réalisée à l’aide d’adition seulement.

EXERCICE 8 : Division récursive

EXERCICE 9 : Suite de Fibonacci

La suite de Fibonacci est définie comme suit :

© Ramzi GUETARI Page 11

Soit la suite définie par :

1. Ecrire un algorithme récursif permettant de calculer le nème terme de la suite.

EXERCICE 11 : Etiquetage de composantes connexes (1D)

EXERCICE 12 : Etiquetage de composantes connexes

© Ramzi GUETARI Page 12

EXERCICE 13 : Triangle de Pascal

Le triangle de Pascal est défini comme suit : les éléments de la première 1

Calculer la complexité suivante :

int foo (int i, int j, int k) {

x = foo (i, j + 1, k - 2);

© Ramzi GUETARI Page 13

© Ramzi GUETARI Page 14

Série d'exercices numéro 3

© Ramzi GUETARI Page 15

EXERCICE 1 : Maximum d'un tableau

Etant donné un tableau X composé de N éléments entiers. On voudrait déterminer son

EXERCICE 2 : Recherche binaire récursive

Soit X un tableau composé de N entiers ordonnés par ordre croissant et Y un entier.

EXERCICE 3 : Recherche récursive du maximum d'une fonction

Soit une fonction à une dimension définie par N échantillons

EXERCICE 4 : Maximum d'une matrice carré

Soit une matrice entière carrée T d’ordre N × N avec N = 2k