Ce document est un mini-projet sur l'algorithmique et la complexité, expliquant la définition des algorithmes, leur efficacité en termes de temps et d'espace, ainsi que les structures de données telles que les tableaux et les listes chaînées. Il traite également de la manipulation des fichiers en C, des exemples d'algorithmes de tri, et des outils de développement comme Code::Blocks. Enfin, il inclut une étude théorique et pratique des algorithmes, ainsi que des implémentations en code C.

1. 26/12/2016 Encadré par :Mr Tragha
Mini-projet en algorithmique et
complexité
réalisé par :
Guebba sara Fagroud fatimaezzahra
Fagroud fati
Par la Pratique On aPPrend l’infOrmatique

2. Rapport Mini-projet
Page 1
I. DEFINITION D’UN ALGORITHME :
Un algorithme est une suite finie et non-ambiguë d’opérations ou d'instructions permettant de
résoudre un problème.
Le mot algorithme vient du nom latinisé du mathématicien persan Al-Khawarizmi, surnommé « le
père de l'algèbre ». Le domaine qui étudie les algorithmes est appelé l'algorithmique. On retrouve
aujourd'hui des algorithmes dans de nombreuses applications telles que la cryptographie, le routage
d'informations, la planification et l'optimisation de ressources, la bio-informatique, ...
1-1)Dans quel cas on dit q’un algorithme est correct ?
Un algorithme est correct lorsque pour chaque instance, il se termine en produisant la bonne sortie,
c'est-à-dire qu'il résout le problème posé. On mesure l'efficacité d'un algorithme notamment par sa
durée pour produire le résultat attendu et par sa consommation de mémoire RAM (en partant du
principe que chaque instruction a un temps d'exécution constant). Les ordinateurs sur lesquels
tournent ces algorithmes ne sont pas infiniment rapides : le temps de machine reste une ressource
limitée malgré une augmentation des performances considérable des machines. Un algorithme sera
donc dit performant s'il utilise avec parcimonie les ressources dont il dispose, c'est-à-dire le temps
CPU et la mémoire RAM.
1-2) la notion de complexité :
La complexité d’un problème mathématique P est une mesure de la quantité de ressources
nécessaires à la résolution du problème P.
L'efficacité d'un algorithme peut être évalué en temps et en espace :
 complexité en temps : évaluation du temps d'exécution de l'algorithme
 complexité en espace : évaluation de l'espace mémoire occupé par l'exécution de l'algorithme
Remarque :
Dans ce rapport, on s’intéresse à la complexité temporelle

3. Rapport Mini-projet
Page 2
On considère, désormais un algorithme dont le temps maximal d’exécution pour une donnée de taille
n en entrée est noté T(n).
Chercher la complexité au pire, dans la situation la plus défavorable, c’est exactement exprimer T(n)
en général en notation « O ».
Voici un dessin des courbes de chacune des complexités pour voir la plus rapide entre eux

4. Rapport Mini-projet
Page 3
II. TABLEAU, LISTE CHAINEE
2-1)C’est quoi un tableau :
 Les tableaux sont des ensembles de variables du même type stockées côte à côte en
mémoire.
 La taille d'un tableau doit être déterminée avant la compilation, elle ne peut pas dépendre
d'une variable.
 Chaque case d'un tableau de type int contient une variable de type int.
 Les cases sont numérotées via des indices commençant à 0
: tableau[0], tableau[1],tableau[2], etc.
2-2) C’est quoi une liste chainée ?
Une liste est une structure de données fondamentale en programmation : elle permet de
représenter une suite d'éléments, et de les manipuler très naturellement.
Cette structure est très adaptée à certains algorithmes de tri, entre autres le tri par insertion
2-3)La différence entre tableau et liste chainée :
 L’accès à un élément de liste chainé ne se fait pas par index mais à l’aide d’un pointeur.
 L’allocation de la mémoire par la liste chainée est faite au moment de l’exécution.
 Pour insérer un élément dans un tableau il aurait fallu déplacer plusieurs éléments mais da
une liste chainée, seulement deux pointeurs sont affectés pour insérer l’élément.
 Le tableau a une seule adresse, pour la liste chainée chaque cellule a son adresse.

5. Rapport Mini-projet
Page 4
III. LES FICHIERS
3-1) C’est quoi un fichier ?
 Un fichier est un ensemble d’information stockées sur une mémoire de masse(disque dur ,clé
..)
 Les informations contenues dans le fichier ne sont pas forcément de même type(un char , un
int ,une structure)
3-2)Manipulation des fichiers
3-2-1 déclaration
FILE *fichier ; majuscule obligatoire par FILE
3-2-2 Ouverture
FILE* fopen(const char* nomDuFichier, const char* modeOuverture);
Les modes d’ouvertures :
 "r" : lecture seule. Vous pourrez lire le contenu du fichier, mais pas y écrire. Le fichier doit avoir été créé
au préalable.
 "w" : écriture seule. Vous pourrez écrire dans le fichier, mais pas lire son contenu. Si le fichier n'existe pas,
il sera créé.
 "a" : mode d'ajout. Vous écrirez dans le fichier, en partant de la fin du fichier. Vous ajouterez donc du
texte à la fin du fichier. Si le fichier n'existe pas, il sera créé.
 "r+" : lecture et écriture. Vous pourrez lire et écrire dans le fichier. Le fichier doit avoir été créé au
préalable.
 "w+" : lecture et écriture, avec suppression du contenu au préalable. Le fichier est donc d'abord vidé de
son contenu, vous pouvez y écrire, et le lire ensuite. Si le fichier n'existe pas, il sera créé.
 "a+" : ajout en lecture / écriture à la fin. Vous écrivez et lisez du texte à partir de la fin du fichier.Si le
fichier n'existe pas, il sera créé.
3-3-3 Fermeture
int fclose(FILE* pointeurSurFichier);
3-3-4 Lecture à partir d’un fichier
 fgetc : lit un caractère .
int fgetc(FILE* pointeurDeFichier)
 fgets : lit une chaîne .
char* fgets(char* chaine, int nbreDeCaracteresALire, FILE* pointeurSurFichier);
 fscanf : lit une chaîne formatée.

6. Rapport Mini-projet
Page 5
fscanf(fichier, typede char", &char)
3-3-5 Ecriture dans le fichier
 fputc : écrit un caractère dans le fichier (UN SEUL caractère à la fois) ;
int fputc(int caractere, FILE* pointeurSurFichier);
 fputs : écrit une chaîne dans le fichier ;
char* fputs(const char* chaine, FILE* pointeurSurFichier);
 fprintf : écrit une chaîne « formatée » dans le fichier, fonctionnement quasi-identique
àprintf.
IV. QUELQUES EXEMPLES DE TRI
4-1) Tri à par insertion
Dans l'algorithme, on parcourt le tableau à trier du début à la fin. Au moment où on considère le i-
ème élément, les éléments qui le précèdent sont déjà triés. Pour faire l'analogie avec l'exemple du
jeu de cartes, lorsqu'on est à la i-ème étape du parcours, le i-ème élément est la carte saisie, les
éléments précédents sont la main triée et les éléments suivants correspondent aux cartes encore
mélangées sur la table.
L'objectif d'une étape est d'insérer le i-ème élément à sa place parmi ceux qui précèdent. Il faut
pour cela trouver où l'élément doit être inséré en le comparant aux autres, puis décaler les
éléments afin de pouvoir effectuer l'insertion. En pratique, ces deux actions sont fréquemment
effectuées en une passe, qui consiste à faire « remonter » l'élément au fur et à mesure jusqu'à
rencontrer un élément plus petit.
procédure tri_insertion(tableau T, entier n)
pour i de 1 à n - 1
# mémoriser la valeur de T[i]
x ← T[i]
# déplacer d'un cran vers la droite les éléments de T[0]..T[i-1]
qui sont plus grands que lui
j ← i
tant que j > 0 et T[j - 1] > x
T[j] ← T[j - 1]
j ← j - 1
fin tant que
# et mettre la valeur dans le "trou" que ça a laissé
T[j] ← x
fin pour

7. Rapport Mini-projet
Page 6
fin procédure
4-2) Tri à par selection
 Sur un tableau de n éléments (numérotés de 1 à n), le principe du tri par sélection est le
suivant :
 rechercher le plus petit élément du tableau, et l'échanger avec l'élément d'indice 1 ;
 rechercher le second plus petit élément du tableau, et l'échanger avec l'élément d'indice 2 ;
 continuer de cette façon jusqu'à ce que le tableau soit entièrement trié.
procédure tri_selection(tableau t, entier n)
pour i de 1 à n - 1
min ← i
pour j de i + 1 à n
si t[j] < t[min], alors min ← j
fin pour
si min ≠ i, alors échanger t[i] et t[min]
fin pour
fin procédure
4-3 Tri par bulle :
Le tri à bulles ou tri par propagation est un algorithme de tri. Il consiste à comparer répétitivement
les éléments consécutifs d'un tableau, et à les permuter lorsqu'ils sont mal triés. Il doit son nom au
fait qu'il déplace rapidement les plus grands éléments en fin de tableau, comme des bulles d'air qui
remonteraient rapidement à la surface d'un liquide.
tri_à_bulles(Tableau T)
pour i allant de taille de T - 1 à 1
pour j allant de 0 à i - 1
si T[j+1] < T[j]
échanger(T[j+1], T[j])
V. OUTILS ET ENVIRONNEMENTS DE DEVELOPPEMENT
5-1) le langage C

8. Rapport Mini-projet
Page 7
C est un langage de programmation impératif et généraliste. Inventé au début des années 1970 pour
réécrire UNIX, C est devenu un des langages les plus utilisés. De nombreux langages plus modernes
comme C++, Java et PHP reprennent des aspects de C.
Le langage C reste un des langages les plus utilisés actuellement. Cela est dû au fait que le langage C
est un langage qui comporte des instructions et des structures de haut niveau (contrairement à
l'assembleur par exemple) tout en générant un code très rapide grâce à un compilateur très
performant.
5-2) le codeblocks
est un environnement de développement intégré libre et multiplateforme. Il est écrit en C++ grâce à
la bibliothèque wxWidgets. CodeBlocks est orienté C et C++, mais il supporte d'autres langages
comme FORTRAN ou le D.
CodeBlocks est développé pour Linux, Windows et Mac OS X. Des utilisateurs indiquent avoir
réussi à compiler le code source sous FreeBSD [réf. nécessaire]3.
CodeBlocks est simple, voire intuitif, d'utilisation pour un programmeur. Il se révèle toutefois
fort complet dès qu'on en explore un peu les options.
Son architecture de plug-ins permet de l'étendre et de le personnaliser, tout en n'y incluant
que ce que l'on souhaite utiliser. La plupart étant inclus dans l'archive et l'installeur, il n'est
de ce fait pas nécessaire de les installer un à un.

9. Rapport Mini-projet
Page 8
VI. ETUDE THEORIQUE :
6-1) Complexité tri par insertion :
Le tri effectue n-1 insertions. A la i ème itération, dans le pire des cas, l’algorithme effectue i-
1 recopies. Le coût du tri est donc : O(n²).
Dans le meilleur des cas le tri par insertion requiert seulement O(n) traitements. C’est le cas
lorsque l’élément à insérer reste à sa place, donc quand la suite est déjà triée. On peut
montrer que le tri par insertion est quadratique en moyenne
6-2) Complexité tri à bulles
Dans le pire des cas, la complexité du tri à bulles est aussi en O(n²). Le pire des cas est, pour
ce tri, une liste triée en sens inverse.
Le meilleur des cas est une liste triée. Si l'algorithme est confronté à ce cas, sa complexité
s'améliore en O(n), ce qui signifie qu'il ne fait que n comparaisons pour n valeurs à trier (en
réalité, pour des raisons d'intervalles, il n'en fait que n-1).
VII. ETUDE PRATIQUE :
Listes chainés
Fonction calculant la longueur de la liste :
Fonction recherche d’un élément :
int lengthList(llist L)
{
int n=0;
llist p=L;
while(p!=NULL)
{
n++;
p=p->nxt;
}
return n;
}
int rechercherElement(llist liste, char *valeur)
{
simple *tmp=liste;
int i=0;

10. Rapport Mini-projet
Page 9
Fonction tri à bulles :
Fonction tri par insertion :
llist Tribulles(llist L)
{int taille=sizeof(char*);
llist Temp=(llist)malloc(taille);
llist temp=L,temp2;
int i,j;
int n=lengthList(L);
for(i=0;i<n-1;i++){
temp=L;temp2=temp->nxt;
while(temp2!=NULL) {
if(strcmp(temp2->val,temp->val)<0)
{ Temp->val=temp->val;
temp->val=temp2->val;
temp2->val=Temp->val;}
temp=temp->nxt;temp2=temp2->nxt; }
} }
void trier(llist l){
llist temp, temp1, temp2;
temp=temp1=temp2=NULL;
char *min;

11. Rapport Mini-projet
Page 10
Fonction ajout en fin d’une liste:
llist ajouterEnFin(llist liste, char *valeur)
{ simple* nouvelElement = malloc(sizeof(simple));
/* On assigne la valeur au nouvel élément */
nouvelElement->val = valeur;
/* On ajoute en fin, donc aucun élément ne va suivre */

12. Rapport Mini-projet
Page 11

13. Rapport Mini-projet
Page 12
Fonction main:
int main()
{
float temps;
clock_t debut, fin;
char a[50];
llist liste=NULL;
FILE *fich;
char *C=malloc(sizeof(C));
char* v=NULL;
fich=fopen("exemple.txt","r");/*ouverture de notre fichier*/
if(fich!=NULL){
while(!feof(fich) ){
fscanf(fich,"%s",C);
v=malloc(strlen(C)+1); /*on alloue de la mémoire notre chaine +1*/
strcpy(v,C);
liste = ajouterEnFin(liste, v);/*on remplie la chaine*/
}
}
fclose(fich);
int choixMenu;/*menu*/
printf("---Menu---nn");
printf("1.afficher votre liste!n");
printf("2.chercher un element!n");
printf("3.Trier la liste (tri par insertion)!n");
printf("4.Trier la liste (tri à bulles)!n");
printf("nVotre choix?nn");
scanf("%d", &choixMenu);

14. Rapport Mini-projet
Page 13
int S;
switch(choixMenu)
{case 1:
debut = clock();
afficherListe(liste);
printf("nn");
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);
switch (S)
{ case 1:
main();
break;
case 0:
break;}
break;
case 2:
debut = clock();
printf("donner l'element à chercher");
scanf("%s",&a);
int p=Recherche(liste,a);
printf("la valeur cherchée est trouve %dnn",p);
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);

15. Rapport Mini-projet
Page 14
switch (S)
{ case 1:
main();
break;
case 0:
return 0;
}
main();
break;
case 3:
debut = clock();
trier(liste);
afficherListe(liste);
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);
switch (S)
{ case 1:
main();
break;
case 0:
return 0;
}
break;

16. Rapport Mini-projet
Page 15
case 4:
debut = clock();
Tribulles(liste);
afficherListe(liste);
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);
switch (S)
{ case 1:
main();
break;
case 0:
return 0;
}
break;
default:
printf("Ce choix n'existe pas dans notre menu !");
break;
}
system("PAUSE");
return 0;
}

17. Rapport Mini-projet
Page 16
Si on choisit 1 :
Si on choisit 2 :
Si on choisit 3:

18. Rapport Mini-projet
Page 17
Si on choisit 4:

19. Rapport Mini-projet
Page 18
Tableaux
Fonction recherche d’un élément :
Fonction tri à bulles :
int recherche(char tab[max][Ma],char val[10])
{
int i,a;
for(i=0;i<max;i++)
{
if(strcmp(val,tab[i])==0)
{
a=i;
break;
}
}
return a; }
void tribulles(char t[max][Ma],int n)
{
int i,j;
char cle[30];
for(i=0;i<n;i++)
{
for(j=n-1;j>=i+1;--j)
{
if(strcmp(t[j-1],t[j])<0)
{
strcpy(cle,t[j-1]);
strcpy(t[j-1],t[j]);
strcpy(t[j],cle);
}
}

20. Rapport Mini-projet
Page 19
Fonction tri par insertion :
void triInsertion ( char tab[max][Ma],int n) /*la fonction de tri par insertion ne retourne rien
donc void*/
{
int i,j;
char cle[30];
for(i=1;i<=n;i++) /* boucle for pour parcours du tableau */
{
j=i;
strcpy(cle,tab[j]);
while( j>=1 && strcmp(tab[j-1],cle)<0) /* boucle while qui fait le test et insert les
éléments */
{
strcpy(tab[j],tab[j-1]);
j=j-1;
strcpy(tab[j],cle);
}

21. Rapport Mini-projet
Page 20
Fonction main :
int main()
{
float temps;
clock_t debut, fin;
char ch[10];
FILE *fich;
int D,i,x;
char C[max]="",T[max][Ma];
char* v;
fich=fopen("exemple.txt","r");
i=0;
if(fich!=NULL){
while(fgets (C,max,fich)!=NULL ){ /*on prend ligne par ligne*/
v=strtok(C," "); /*on divise ligne en mot par strtok*/
while(v!=NULL && i<max){
strcpy(T[i],v);
v=strtok(NULL," ");
i++;
} } }
printf("nnn");
int choixMenu;
printf("---Menu---nn");
printf("1.afficher votre tableau !n");
printf("2.chercher un element!n");
printf("3.Trier le tableau (tri par insertion)!n");
printf("4.Trier le tableau (tri à bulles)!n");
printf("nVotre choix?nn");
scanf("%d", &choixMenu);
if(choixMenu==1){

22. Rapport Mini-projet
Page 21
int S;
if(choixMenu==1){
debut = clock();
for(x=0;x<i;x++){
printf("tT[%d]=%s",x,T[x]);
printf("nn");}
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);
{if(S==1)
main();
else
return 0; } }
if(choixMenu==2){
debut = clock();
printf("donner l'element à chercher");
scanf("%s",&ch);
D=recherche(T,ch);
printf("la valeur cherchée se trouve %da",D);
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);
if(S==1)
{
main();}
else
return 0;
}

23. Rapport Mini-projet
Page 22
if(choixMenu==3) {
debut = clock();
triInsertion(T,10);
for(i=0;i<10;i++){
printf(" T[%d]=%s ",i,T[i]);}
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);
if(S==1)
{
main();}
else
return 0;
}
if(choixMenu==4) {
debut = clock();
tribulles(T,10);
for(i=0;i<10;i++){
printf(" T[%d]=%s ",i,T[i]);}
fin= clock();
temps = (float)(fin-debut)/CLOCKS_PER_SEC;
printf("ntemps = %fn", temps);
printf("vous voulez continuer taper 1 pour continuer et 0 pour exit");
scanf("%d",&S);
if(S==1)
{
main();}
else
return 0;
}

24. Rapport Mini-projet
Page 23
Si on tape 1 :
Si on tape 2 :
else
printf("Ce choix n'existe pas dans notre menu !");}
}

25. Rapport Mini-projet
Page 24
Si on tape 3 :
Si on tape 4 :

26. Rapport Mini-projet
Page 25
On a pour le tri par insertion ou par bulles la compléxité soit pour les listes chainées ou par les tableaus
vaut
O(n²)
Donc pour le temps d’éxecution du tri par insertion dans le tableau :
Pour les listes chainées on a :
Complexité
théorique
Temps d’exécution
avec structure 1
(tableaux)
Temps d’exécution
avec structure 2
(liste chainée)
Algorithme 1 : tri par
insertion
O(n²) 0.002 0.001
Algorithme 2 : tri à
bulles
O(n²) 0.000 0.001
Algorithme 3 :
recherche
sequentielle
O(n) 2.56 3.77

27. Rapport Mini-projet
Page 26
Pour le tri par bulle pour le tableau :

28. Rapport Mini-projet
Page 27
Pour le tri des listes chainées par bulle :
Pour la recherche d’un mot dans le tableau :
Pour la recherche d’un mot dans la liste

29. Rapport Mini-projet
Page 28