** L’information n’est pas le savoir, le savoir n’est pas la sagesse, la sagesse n’est l’amour, l’amour

n’est pas la musique et la musique c’est ce qu’il y a de mieux **

Recueil d’exercices

En informatique il faut savoir de quoi tu as besoin comme entrée et comme sortie

On dispose d'un fichier texte contenant des données de la forme :

P28432 Daouda Mané L2NP1

P27500 Fatou Seck L31NFO
P27757 Ibra Ka
L3MIAGE
P30534 Moussa Wague L2MP1
décrivant respectivement le code d'un étudiant, son prénom, son nom et sa classe.

On voudrait écrire une commande qui à partir d'un fichier de cette forme récupère toutes les
données dans une liste chaînée et y effectue une recherche par un code. Les arguments seront
donnés sur la ligne de commande. Un exemple d'exécution de la commande est donné ci-après .

recherche etudiants P27438 où « recherche » est le nom de la

commande, « etudiants » est le nom du fichier ci-dessus et « P27438 » un code d' étudiant. Il
faudra pour cela écrire trois fonctions .
1. une permettant de lire le fichier et de mettre les informations dans la liste chaînée. L'ordre
d'apparition sera la même que celui dans le fichier. On utilisera la combinaison « fgetssscanf
»;

une permettant de rechercher le code dans la liste chaînée. Cette fonction

renvoie toutes les informations sur l'étudiant en question ; 3) une
fonction « main ».
#include <stdio.h>
#include <stdlib.h>

#include <string.h>

Struct etudiant {

Char code[7] ;

Char prenom[20] ;

Char nom[20] ;

Char classe[7] ;

Struct etudiant *next ;

};
Struct etudiant *lire_fichier(char *nom_fichier) {

Struct etudiant *premier = NULL ;

Struct etudiant *dernier = NULL ;

FILE *f = fopen(nom_fichier, « r ») ;

If (f == NULL) {

Printf(« Impossible d’ouvrir le fichier %s\n », nom_fichier) ;

Return NULL ;

While ( !feof(f)) {

Struct etudiant *e = (struct etudiant *)malloc(sizeof(struct etudiant)) ;

If (fscanf(f, « %s %s %s %s\n », e->code, e->prenom, e->nom, e->classe) != 4) {

Free(e);

Break ;

e->next = NULL ;

if (premier == NULL) {

premier = e ;

} else {

Dernier->next = e ;

Dernier = e ;

Fclose(f) ;

Return premier ;

Struct etudiant *rechercher_code(struct etudiant *liste, char *code) {

Struct etudiant *e = liste ;

While (e != NULL) {

If (strcmp(e->code, code) == 0) {

Return e ;
 }

e = e->next ;

Return NULL ;

Int main(int argc, char *argv[]) {

If (argc != 3) {

Printf(« Usage : %s etudiants P27438\n », argv[0]) ;

Return 1 ;

Struct etudiant *liste = lire_fichier(argv[1]) ;

If (liste == NULL) {

Return 1 ;

Struct etudiant *e = rechercher_code(liste, argv[2]) ;

If (e == NULL) {

Printf(« Aucun étudiant trouvé avec le code %s\n », argv[2]) ;

} else {

Printf(« Code : %s\n », e->code) ;

Printf(« Prénom : %s\n », e->prenom) ;

Printf(« Nom : %s\n », e->nom) ;

Printf(« Classe : %s\n », e->classe) ;

Return 0 ;

S. Ndao de Tattaguine
 Considérons un étudiant
défini par son identifiant, son
nom, son prénom et sa date de
naissance.
La date de naissance est
définie par le jour, le mois et
l'année.
2. Définir le type « Etudiant ».
3. Ecrire une fonction Tableau
VersListe qui transforme un
tableau d' étudiants en liste
chaînée. La fonction doit
retourner un pointeur qui
indique la tête de la liste.
L'ordre des éléments de la
 liste obtenue est le même
que celui du tableau.
4. Ecrire une fonction qui
affiche et permet de
vérifier résultat obtenu ;
5. Ecrire une fonction qui
permet de rechercher un
étudiant dans la liste par son
identifiant ; la fonction
permettra de récupérer'
toutes les informations sur
l'étudiant dans la fonction
appelante ;
Rajouter une fonction main »
qui crée un tableau d'étudiants
et appelle les fonctions
précédentes.
Struct Etudiant {
Int identifiant ;

Char nom[50] ;

Char prenom[50] ;

Struct {

Int jour ;

Int mois ;

Int annee ;

} dateDeNaissance ;

};

Struct EtudiantNode {

Struct Etudiant data ;

Struct EtudiantNode* next ;

};

Struct EtudiantNode* TableauVersListe(struct Etudiant tableau[], int tailleTableau) {

Struct EtudiantNode* tete = NULL ;

Struct EtudiantNode* courant = NULL ;

For (int i = 0 ; i < tailleTableau ; i++) {

Struct EtudiantNode* newNode = (struct EtudiantNode*)malloc(sizeof(struct EtudiantNode)) ;

newNode->data = tableau[i] ;

newNode->next = NULL ;

if (tete == NULL) {

tete = newNode ;

} else {
 Courant->next = newNode ;

Courant = newNode ;

Return tete ;

Void AfficherEtudiant(struct Etudiant e) {

Printf(« Identifiant : %d\n », e.identifiant) ;

Printf(« Nom : %s\n », e.nom) ;

Printf(« Prénom : %s\n », e.prenom) ;

Printf(« Date de naissance : %d/%d/%d\n », e.dateDeNaissance.jour, e.dateDeNaissance.mois,

e.dateDeNaissance.annee) ;

Void AfficherListeEtudiants(struct EtudiantNode* tete) {

Struct EtudiantNode* courant = tete ;

While (courant != NULL) {

AfficherEtudiant(courant->data) ;

Courant = courant->next ;

Struct Etudiant* RechercherEtudiantParId(struct EtudiantNode* tete, int id) {

Struct EtudiantNode* courant = tete ;

While (courant != NULL) {

If (courant->data.identifiant == id) {

Return &(courant->data) ;

Courant = courant->next ;

Return NULL ;

}
#include <stdio.h>

#include <stdlib.h>

Typedef struct {

Int jour ;

Int mois ;

Int annee ;

} DateNaissance ;

Typedef struct Etudiant {

Int identifiant ;

Char nom[100] ;

Char prenom[100] ;

DateNaissance dateNaissance ;

Struct Etudiant *suivant ;

} Etudiant ;

Etudiant *TableauVersListe(Etudiant tableauEtudiants[], int tailleTableau) {

Etudiant *tete = NULL ;

Etudiant *precedent = NULL ;

For (int i = 0 ; i < tailleTableau ; i++) {

Etudiant *nouvelEtudiant = (Etudiant *)malloc(sizeof(Etudiant)) ;

*nouvelEtudiant = tableauEtudiants[i] ;

nouvelEtudiant->suivant = NULL ;

if (precedent != NULL) {

precedent->suivant = nouvelEtudiant ;

If (tete == NULL) {

Tete = nouvelEtudiant ;

Precedent = nouvelEtudiant ;
 }

Return tete ;

Void AfficherListe(Etudiant *tete) {

Etudiant *etudiantActuel = tete ;

While (etudiantActuel != NULL) {

Printf(« Identifiant : %d\n », etudiantActuel->identifiant) ;

Printf(« Nom : %s\n », etudiantActuel->nom) ;

Printf(« Prénom : %s\n », etudiantActuel->prenom) ;

Printf(« Date de naissance : %d/%d/%d\n », etudiantActuel->dateNaissance.jour, etudiantActuel-

>dateNaissance.mois, etudiantActuel->dateNaissance.annee) ;

Printf(« \n ») ;

etudiantActuel = etudiantActuel->suivant ;

Etudiant *RechercherEtudiant(Etudiant *tete, int identifiantRecherche) {

Etudiant *etudiantActuel = tete ;

While (etudiantActuel != NULL) {

If (etudiantActuel->identifiant == identifiantRecherche) {

Return etudiantActuel ;

etudiantActuel = etudiantActuel->suivant ;

Return NULL ;

Int main() {

Etudiant tableauEtudiants[3] = {
 {1, « Dupont », « Jacques », {12, 5, 1990}, NULL},

{2, « Durand », « Paul », {3, 10, 1991}, NULL},

{3, « Martin », « Marie », {15, 8, 1992}, NULL}

};

Etudiant *teteListeEtudiants = TableauVersListe(tableauEtudiants, 3) ;

Printf(« Liste d’étudiants:\n ») ;

AfficherListe(teteListeEtudiants) ;

Int identifiantRecherche = 2 ;

Etudiant *etudiantTrouve = RechercherEtudiant(teteListeEtudiants, identifiantRecherche) ;

If (etudiantTrouve != NULL) {

Printf(« L’étudiant avec l’identifiant %d a été trouvé:\n », identifiantRecherche) ;

Printf(« Identifiant : %d\n », etudiantTrouve->identifiant) ;

Printf(« Nom : %s\n », etudiantTrouve->nom) ;

Printf(« Prénom : %s\n », etudiantTrouve->prenom) ;

Printf(« Date de naissance : %d/%d/%d\n », etudiantTrouve->dateNaissance.jour, etudiantTrouve-

>dateNaissance.mois, etudiantTrouve->dateNaissance.annee) ;

} else {

Printf(« L’étudiant avec l’identifiant %d n’a pas été trouvé.\n », identifiantRecherche) ;

Return 0 ;

Un document est défini par son titre, son auteur, et peut avoir jusqu’à sept mots-cés,

1 .Définir une structure « Document » et les différentes fonctions listées ci-dessous :

2 .Une fonction de création d'un document à partir de ses caractéristiques; elle fait l'allocation
dynamique d'un pointeur sur un document et renvoie ce dernier;

3. Une fonction de destruction d’un document ;

4. une fonction permettant d'ajouter un mot-clé à la liste des mots-clés.

5 .une fonction permettant de savoir si un document contient un certain mot-clé

6 .une fonction permettant de récupérer le titre du document;

7.une fonction permettant de faire la copie d'un document

une fonction permettant de récupérer le ième mot-clé;

Une fonction d’affichage d’un document ;

Tester votre implémentation en créant des documents et en leur appliquant ces différentes

Correction :

#define MAX_KEYWORDS 7

Typedef struct {

Char* title ;

Char* author ;

Char* keywords[MAX_KEYWORDS] ;

Int num_keywords ;

} Document ;

Document* create_document(char* title, char* author) {

Document* doc = (Document*) malloc(sizeof(Document)) ;

Doc->title = title ;

Doc->author = author ;

Doc->num_keywords = 0 ;

Return doc ;

}
Void destroy_document(Document* doc) {

Free(doc->title) ;

Free(doc->author) ;

For (int i = 0 ; i < doc->num_keywords ; i++) {

Free(doc->keywords[i]) ;

Free(doc) ;

Void add_keyword(Document* doc, char* keyword) {

If (doc->num_keywords < MAX_KEYWORDS) {

Doc->keywords[doc->num_keywords] = keyword ;

Doc->num_keywords++ ;

Bool has_keyword(Document* doc, char* keyword) {

For (int i = 0 ; i < doc->num_keywords ; i++) {

If (strcmp(doc->keywords[i], keyword) == 0) {

Return true ;

Return false ;

Char* get_title(Document* doc) {

Return doc->title ;

Document* copy_document(Document* doc) {

 Document* copy = create_document(doc->title, doc->author) ;

For (int i = 0 ; i < doc->num_keywords ; i++) {

Add_keyword(copy, doc->keywords[i]) ;

Return copy ;

Char* get_keyword(Document* doc, int index) {

If (index < doc->num_keywords) {

Return doc->keywords[index] ;

Return NULL ;

Void print_document(Document* doc) {

Printf(« Title : %s\n », doc->title) ;

Printf(« Author : %s\n », doc->author) ;

Printf(« Keywords : « ) ;

For (int i = 0 ; i < doc->num_keywords ; i++) {

Printf(« %s « , doc->keywords[i]) ;

Printf(« \n ») ;

***†******************************”****************

On veut écrire un programme permettant de gérer le personnel d'une entreprise. Les membres du
personnel d'une entreprise sont définis comme suit:

Oumar Fall H Ingénieur 2 200 000

Fatou Seck F Secrétaire 7 500 000

Demba Aw H Technicien 4 350 000

Moussa Gningue H Ingénieur 2 200 000

Daba Faye F Ingénieur 3 450 000

respectivement par leur prénom, le nom, le sexe, le métier, le nombre d'années d'expérience et le
salaire. L'entreprise est définie par un tableau de N (à définir) membres du personnel.

1. Déclarer dans un fichier « Entreprise.h» le type « Membres Personnels », le type

<<Entreprise » correspondant ainsi que les fonctions suivantes :

2. Écrire dans un fichier « Entreprise.c les définitions de fonctions correspondantes.

a. Saisie d’un tableau de membres du personnel ;

b. Affichage de tous les membres de l’entreprise ;

c. Affichage les membres dont le salaire est supérieur à 300000 ;

d. Affichage des informations sur toutes femmes secrétaire ;

e. Affichage des informations sur tous les ingenieurs

f. Calcul de la masse salariale de l’entreprise ;

3. On voudrait maintenant sélectionner une femme parmi les ingénieurs dont le nombre
d’expériences dépasse 5 ans. Expliquer comment le faire et écrire la (ou les) fonction(s)
correspondantes ;

4. Dans le fichier «main.c », il faudra saisir le tableau des N membres de l’entreprise et appeler les
différentes fonctions. Il faudra également afficher la femme sélectionnée si elle existe.

Salutations :

#ifndef ENTREPRISE_H

#define ENTREPRISE_H

#define N 10

Typedef struct {

Char prenom[30] ;

Char nom[30] ;

Char sexe ;

Char metier[30] ;
 Int anneesExperience ;

Int salaire ;

} MembrePersonnel ;

Typedef struct {

MembrePersonnel personnel[N] ;

Int nbMembres ;

} Entreprise ;

Void saisirMembrePersonnel(Entreprise *entreprise) ;

Void afficherMembrePersonnel(MembrePersonnel membre) ;

Void afficherEntreprise(Entreprise entreprise) ;

Void afficherMembresSuperieurSalaire(Entreprise entreprise, int salaire) ;

Void afficherMembresFemmeSecretaire(Entreprise entreprise) ;

Void afficherMembresIngenieur(Entreprise entreprise) ;

Int masseSalarialeEntreprise(Entreprise entreprise) ;

MembrePersonnel selectionnerFemmeIngenieurExperience(Entreprise entreprise) ;

#endif

#include <stdio.h>

#include « Entreprise.h »

Void saisirMembrePersonnel(Entreprise *entreprise) {

Int I ;

for(I=0 ;I<entreprise->nbMembre ;I++) {

Printf(« Saisir prenom : « ) ;

Scanf(« %s », entreprise->personnel[I].prenom) ;

Printf(« Saisir nom : « ) ;

Scanf(« %s », entreprise->personnel[I].nom) ;

Printf(« Saisir sexe (H/F) : « ) ;

 Scanf(« %c », &(entreprise->personnel[I].sexe)) ;

Printf(« Saisir metier : « ) ;

Scanf(« %s », entreprise->personnel[I].metier) ;

Printf(« Saisir nombre d’années d’experience : « ) ;

Scanf(« %d », &(entreprise->personnel[I].anneesExperience)) ;

Printf(« Saisir salaire : « ) ;

Scanf(« %d », &(entreprise->personnel[I].salaire)) ;

Void afficherMembrePersonnel(MembrePersonnel membre) {

Printf(« %s %s (%c) - %s - %d ans d’experience – salaire : %d\n »,

Membre.prenom, membre.nom, membre.sexe, membre.metier,

Membre.anneesExperience, membre.salaire) ;

Void afficherEntreprise(Entreprise entreprise) {

Int i ;

for (i = 0 ; i < entreprise.nbMembres ; i++) {

afficherMembrePersonnel(entreprise.personnel[i]) ;

Void afficherMembresSalaireSuperieur(Entreprise ent, int salaire) {

Printf(« Membres avec un salaire supérieur à %d:\n », salaire) ;

for (int i = 0 ; i < ent.n ; i++) {

If (ent.membres[i].salaire > salaire) {

afficherMembre(ent.personnel[i]) ;

}
 }

Void afficherFemmesSecretaires(Entreprise ent) {

Printf(« Femmes secrétaires:\n ») ;

for (int i = 0 ; i < ent.n ; i++) {

If (ent.membres[i].sexe == ‘F’ && strcmp(ent.membres[i].metier, « Secrétaire ») == 0) {

afficherMembre(ent.personnel[i]) ;

Void afficherIngenieurs(Entreprise ent) {

Printf(« Ingénieurs:\n ») ;

for (int i = 0 ; i < ent.n ; i++) {

If (strcmp(ent.membres[i].metier, « Ingénieur ») == 0) {

afficherMembre(ent.personnel[i]) ;

Int masseSalariale(Entreprise ent) {

Int somme = 0 ;

for (int i = 0 ; i < ent.n ; i++) {

Somme += ent.personnel[i].salaire ;

Return somme ;

#include <stdio.h>
#include « Entreprise.h »

Int main() {

Entreprise ent ;

ent.nbMembre = 5 ;

saisirEntreprise(&ent) ;

afficherEntreprise(ent) ;

printf(« \n ») ;

afficherMembresSalaireSuperieur(ent, 300000) ;

printf(« \n ») ;

afficherFemmesSecretaires(ent) ;

printf(« \n ») ;

afficherIngenieurs(ent) ;

printf(« \n ») ;

printf(« Masse salariale : %d\n », masseSalariale(ent)) ;

return 0 ;

Lecture de fichier structuré.

Khoulyo081@gmail.com

« Exercice 4

Soit un fichier de données structurées en une suite de lignes contenant chacune un nom de
personne, un nom de pièce, un nombre et un prix. Exemple :

Fall raquette 10 1000

Dem brosse 50 567

 1) Écrire un programme qui contient les fonctions suivantes :

Une fonction qui lit le fichier et mémorise son contenu dans un tableau de structures, chaque
structure permettant de mémoriser le contenu d’une ligne (nom, article, nombre et prix) et
correspondant ainsi à une commande. La lecture se fera par un appel à fscanf.

Une fonction qui parcourt ensuite ce tableau en imprimant le contenu de chaque structure

Les fonctions seront appelées du programme principal.

2) Reprendre l’exercice ci-dessus en mémorisant le fichier de données non pas dans un tableau
de structures, mais dans une liste chaînée de structures.

3) Rajouter une fonction de recherche de commande maximum (celle pour laquelle le produit
nombre*prix est maximum). Cette fonction prend en paramètre un pointeur vers la structure
commande qui est en tête de la liste complète et renvoie un pointeur vers la structure
recherche .

Voici une proposition de solution pour cet exercice :

Solution

2/2

Khoulyo081@gmail.com

Solution avec tableau de structures :

#include <stdio.h>
#define MAX_COMMANDES 100

// Définition de la structure commande

Struct commande {

Char nom[50] ;

Char article[50] ;

Int nombre ;

Float prix ;

};

// Fonction pour lire le fichier et stocker les commandes dans un tableau de structures

// Jusque là nous ne connaissons pas la taille pour faire nous allons compter le nombre de types qui
sont dans le fichier avec boucle tantque

Int lire_fichier_tableau(struct commande commandes[]) {

FILE* fichier = fopen(« fichier.txt », « r ») ;

Int nb_commandes = 0 ;

If (fichier == NULL) {

Printf(« Erreur lors de l’ouverture du fichier. ») ;

Return 0 ;

While (fscanf(fichier, « %s %s %d %f », commandes[nb_commandes].nom,

commandes[nb_commandes].article, &commandes[nb_commandes].nombre,
&commandes[nb_commandes].prix) == 4) {

Nb_commandes++ ;

Fclose(fichier) ;

Return nb_commandes ;

}
// Fonction pour parcourir le tableau de structures et afficher les commandes

Void afficher_commandes_tableau(struct commande commandes[], int nb_commandes) {

Printf(« Liste des commandes:\n ») ;

For (int i = 0 ; i < nb_commandes ; i++) {

Printf(« %s %s %d %.2f\n », commandes[i].nom, commandes[i].article, commandes[i].nombre,

commandes[i].prix) ;

Int main() {

Struct commande commandes[MAX_COMMANDES] ;

Int nb_commandes = lire_fichier_tableau(commandes) ;

Afficher_commandes_tableau(commandes, nb_commandes) ;

Return 0 ;

Solution avec liste chaînée de structures :

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

// Définition de la structure commande

Struct commande {

Char nom[50] ;

Char article[50] ;

Int nombre ;

Float prix ;

Struct commande* suivante ;

};
// Fonction pour ajouter une commande à la liste chaînée

Void ajouter_commande_liste(struct commande** liste, char nom[], char article[], int nombre, float
prix) {

Struct commande* nouvelle_commande = (struct commande*)malloc(sizeof(struct commande)) ;

Strcpy(nouvelle_commande->nom, nom) ;

Strcpy(nouvelle_commande->article, article) ;

Nouvelle_commande->nombre = nombre ;

Nouvelle_commande->prix = prix ;

Nouvelle_commande->suivante = *liste ;

*liste = nouvelle_commande ;

// Fonction pour lire le fichier et stocker les commandes dans une liste chaînée de structures

Void lire_fichier_liste(struct commande** liste) {

FILE* fichier = fopen(« fichier.txt », « r ») ;

If (fichier == NULL) {

Printf(« Erreur lors de l’ouverture du fichier. ») ;

Return ;

Char nom[50] ;

Char article[50] ;

Int nombre ;

Float prix ;

While (fscanf(fichier, « %s %s %d %f », nom, article, &nombre, &prix) == 4) {

Ajouter_commande_liste(liste, nom, article, nombre, prix) ;

Fclose(fichier) ;
}

// Fonction pour parcourir la liste chaînée de structures et afficher les commandes

Void afficher_commandes_liste(struct commande* liste) {

Printf(« Liste des commandes:\n ») ;

While (liste != NULL) {

Printf(« %s %s %d %.2f\n », liste->nom, liste->article, liste->nombre, liste->prix) ;

Liste = liste->suivante ;

Voici la suite du programme avec la troisième fonction de recherche de commande maximum :

// Fonction pour rechercher la commande avec le produit nombre*prix maximum

Struct commande* chercher_commande_max(struct commande* liste) {

Struct commande* commande_max = liste ;

Float produit_max = commande_max->nombre * commande_max->prix ;

While (liste != NULL) {

Float produit_courant = liste->nombre * liste->prix ;

If (produit_courant > produit_max) {

Produit_max = produit_courant ;

Commande_max = liste ;

Liste = liste->suivante ;

Return commande_max ;

}
Int main() {

Struct commande* liste_commandes = NULL ;

Lire_fichier_liste(&liste_commandes) ;

Afficher_commandes_liste(liste_commandes) ;

Struct commande* commande_max = chercher_commande_max(liste_commandes) ;

Printf(« Commande avec produit maximum : %s %s %d %.2f\n », commande_max->nom,

commande_max->article, commande_max->nombre, commande_max->prix) ;

Return 0 ;

Notez que la fonction ajouter_commande_liste a été ajoutée pour permettre l’ajout d’une nouvelle
commande à la liste chaînée, la fonction lire_fichier_liste pour lire le fichier et remplir la liste
chaînée, et la fonction afficher_commandes_liste pour afficher les commandes de la liste chaînée. La
fonction chercher_commande_max permet quant à elle de chercher la commande pour laquelle le
produit nombre*prix est maximum.

Programme en C.

Khoulyo081@gmail.com

Ecrire un programme qui lit une suite d’entiers à la console et crée la liste chaînée correspondante
dans les deux cas :

1. La liste doit traduire l’ordre de lecture des entiers

2. Les entiers doivent être ranges par ordre croissant (au fur et à mesure de la création de la liste)

3.Rajouter les fonctions suivantes :

a)Affichage de tous les éléments de la liste ;

b)Recherche d’un élément de la liste renvoie le premier maillon qui contient la valeur ;

c. Concaténation de deux listes chainées ;

d. Suppression du premier maillon contenant l’élément

e. Suppression de tous les maillons contenant l’élément

 1. Recopie d’une liste chainée en conservant l’ordre des éléments

Recopie d’une liste chaînée en inversant l’ordre des éléments

Salutations :::

#include <stdio.h>

#include <stdlib.h>

// Définition de la structure de la liste chaînée

Typedef struct Node {

Int data ;

Struct Node* next ;

} Node ;

// Fonction pour ajouter un élément à la fin de la liste

Void append(Node** headRef, int newData) {

Node* newNode = (Node*)malloc(sizeof(Node)) ;

Node* last = *headRef ;

newNode->data = newData ;

newNode->next = NULL ;

if (*headRef == NULL) {

*headRef = newNode ;

Return ;

While (last->next != NULL) {

Last = last->next ;

Last->next = newNode ;

Return ;
}

// Fonction pour ajouter un élément à la liste de manière ordonnée

Void insertSorted(Node** headRef, int newData) {

Node* newNode = (Node*)malloc(sizeof(Node)) ;

newNode->data = newData ;

newNode->next = NULL ;

if (*headRef == NULL || (*headRef)->data >= newData) {

newNode->next = *headRef ;

*headRef = newNode ;

Return ;

Node* current = *headRef ;

While (current->next != NULL && current->next->data < newData) {

Current = current->next ;

newNode->next = current->next ;

current->next = newNode ;

// Fonction pour afficher tous les éléments de la liste

Void printList(Node* node) {

While (node != NULL) {

Printf(« %d « , node->data) ;

Node = node->next ;

Printf(« \n ») ;
}

// Fonction pour rechercher un élément de la liste

Node* search(Node* head, int key) {

Node* current = head ;

While (current != NULL) {

If (current->data == key) {

Return current ;

Current = current->next ;

Return NULL ;

// Fonction pour concaténer deux listes chaînées

Node* concatenate(Node* head1, Node* head2) {

Node* current = head1 ;

While (current->next != NULL) {

Current = current->next ;

Current->next = head2 ;

Return head1 ;

// Fonction pour supprimer le premier maillon contenant l’élément

Void deleteNode(Node** headRef, int key) {

Node* temp = *headRef ;

Node* prev = NULL ;

If (temp != NULL && temp->data == key) {

*headRef = temp->next ;

Free(temp) ;
 Return ;

While (temp != NULL && temp->data != key) {

Prev = temp ;

Temp = temp->next ;

If (temp == NULL) {

Return ;

Prev->next = temp->next ;

Free(temp) ;

// Fonction pour supprimer tous les maillons contenant l’élément

Void deleteAll(Node** headRef, int key) {

Node* temp = *headRef ;

Node* prev = NULL ;

While (temp != NULL && temp->data == key) {

*headRef = temp->next ;

Free(temp) ;

Temp = *headRef ;

While (temp != NULL) {

While (temp != NULL && temp->data != key) {

Prev = temp ;

Temp = temp->next ;

// Fonction pour recopier une liste chaînée en conservant l’ordre des éléments

Node* copyList(Node* head) {

Node* current = head ;

Node* newList = NULL ;

 Node* last = NULL ;

While (current != NULL) {

Node* newNode = (Node*)malloc(sizeof(Node)) ;

newNode->data = current->data ;

newNode->next = NULL ;

if (newList == NULL) {

newList = newNode ;

last = newNode ;

} else {

Last->next = newNode ;

Last = newNode ;

Current = current->next ;

Return newList ;

// Fonction pour recopier une liste chaînée en inversant l’ordre des éléments

Node* reverseList(Node* head) {

Node* prev = NULL ;

Node* current = head ;

Node* next = NULL ;

While (current != NULL) {

Next = current->next ;

Current->next = prev ;

Prev = current ;
 Current = next ;

Return prev ;

// Fonction pour concaténer deux listes chaînées

Node* concatenateLists(Node* head1, Node* head2) {

If (head1 == NULL) {

Return head2 ;

If (head2 == NULL) {

Return head1 ;

Node* current = head1 ;

While (current->next != NULL) {

Current = current->next ;

Current->next = head2 ;

Return head1 ;

// Fonction pour recopier une liste chaînée en inversant l’ordre des éléments

Node* reverseListCopy(Node* head) {

Node* current = head ;

Node* newList = NULL ;

While (current != NULL) {

 Node* newNode = (Node*)malloc(sizeof(Node)) ;

newNode->data = current->data ;

newNode->next = newList ;

newList = newNode ;

current = current->next ;

Return newList ;

Une bibliothèque est définie par nom, son université d’appartenance, un tableau de N livres et le
nombre courant de livres. Chaque livre est ainsi défini par son identifiant (chaîne de caractères), son
titre, son auteur et sa discipline.

1) Définir le type << LIVRE » et le type «< BIBLIOTHEQUE>>.

2) Écrire une fonction qui reçoit en argument un livre et qui en remplit les différents champs ;

3) Écrire une fonction qui rajoute un livre à la bibliothèque , un livre ne doit pas être ajouté deux
fois ;

4) Écrire une fonction qui recherche un livre par son identifiant ;

5) Écrire une fonction qui supprime un livre de la bibliothèque ;
6) Écrire une fonction qui affiche le premier livre de la bibliothèque en informatique qu’elle
trouve avec toutes les informations le concernant ;
7) Écrire une fonction qui affiche tous les livres d’une université donnée ;
8) Écrire une fonction qui affiche toutes les bibliothèques d’une université donnée ;
9) Écrire une fonction qui permet de trouver l’intersection des livres de deux bibliothèques ;
10) Rajouter une fonction «<main>> qui crée une bibliothèque, rajoute un certain nombre de
livres et appelle les différentes fonctions.
Correction :
#include <stdio.h>
#include <string.h>

#define MAX_LIVRES 100

#define MAX_BIBLIO 100

Typedef struct {
Char identifiant[50] ;
Char titre[100] ;
Char auteur[100] ;
Char discipline[100] ;
} Livre ;

Typedef struct {
Char nom[100] ;
Char universite[100] ;
Livre livres[MAX_LIVRES] ;
Int nbLivres ;
} Bibliotheque ;

Void remplirLivre(Livre* livre, char* id, char* titre, char* auteur, char* discipline) {
Strcpy(livre->identifiant, id) ;
Strcpy(livre->titre, titre) ;
Strcpy(livre->auteur, auteur) ;
Strcpy(livre->discipline, discipline) ;
}

Int ajouterLivre(Bibliotheque* biblio, Livre livre) {

Int i ;
For (i = 0 ; i < biblio->nbLivres ; i++) {
If (strcmp(biblio->livres[i].identifiant, livre.identifiant) == 0) {
Return 0 ; // le livre existe déjà dans la bibliothèque
}
}
If (biblio->nbLivres >= MAX_LIVRES) {
Return -1 ; // la bibliothèque est pleine
}
Biblio->livres[biblio->nbLivres++] = livre ;
Return 1 ; // le livre a été ajouté à la bibliothèque
}

Livre* chercherLivre(Bibliotheque* biblio, char* id) {

Int i ;
For (i = 0 ; i < biblio->nbLivres ; i++) {
If (strcmp(biblio->livres[i].identifiant, id) == 0) {
Return &biblio->livres[i] ; // le livre a été trouvé
}
}
Return NULL ; // le livre n’a pas été trouvé dans la bibliothèque
}

Int supprimerLivre(Bibliotheque* biblio, char* id) {

Int i ;
For (i = 0 ; i < biblio->nbLivres ; i++) {
If (strcmp(biblio->livres[i].identifiant, id) == 0) {
Biblio->livres[i] = biblio->livres[--biblio->nbLivres] ; // on remplace le livre à supprimer
par le dernier livre
Return 1 ; // le livre a été supprimé
}
 }
Return 0 ; // le livre n’a pas été trouvé dans la bibliothèque
}

Void afficherPremierLivre(Bibliotheque* biblio) {

If (biblio->nbLivres > 0) {
Livre livre = biblio->livres[0] ;
Printf(« Identifiant : %s\nTitre : %s\nAuteur : %s\nDiscipline : %s\n », livre.identifiant,
livre.titre, livre.auteur, livre.discipline) ;
} else {
Printf(« La bibliothèque est vide.\n ») ;
}
}

Void afficherLivresUniversite0(Bibliotheque bibliotheque, char* universite) {

Int i ;
Printf(« Livres de l’universite %s:\n », universite) ;
For (i = 0 ; i < bibliotheque.nbLivres ; i++) {
If (strcmp(bibliotheque.livres[i].universite, universite) == 0) {
Printf(« Identifiant : %s\n », bibliotheque.livres[i].identifiant) ;
Printf(« Titre : %s\n », bibliotheque.livres[i].titre) ;
Printf(« Auteur : %s\n », bibliotheque.livres[i].auteur) ;
Printf(« Discipline : %s\n », bibliotheque.livres[i].discipline) ;
Printf(« \n ») ;
}
}
}

Void afficherLivresUniversite1(Bibliotheque* biblio, char* universite) {

Int i ;
For (i = 0 ; i < biblio->nbLivres ; i++) {
If (strcmp(biblio->livres[i].universite, universite) == 0) {
Printf(« Identifiant : %s\nTitre : %s\nAuteur : %s\nDiscipline : %s\n », biblio-
>livres[i].identifiant, biblio->livres[i].titre, biblio->livres[i].auteur, biblio->livres[i].discipline) ;
}
}
}

Void trouverIntersectionLivres(Bibliotheque* biblio1, Bibliotheque* biblio2) {

Int i, j ;
For (i = 0 ; i < biblio1->nbLivres ; i++) {
For (j = 0 ; j < biblio2->nbLivres ; j++) {
If (strcmp(biblio1->livres[i].identifiant, biblio2->livres[j].identifiant) == 0) {
Printf(« Identifiant : %s\nTitre : %s\nAuteur : %s\nDiscipline : %s\n », biblio1-
>livres[i].identifiant, biblio1->livres[i].titre, biblio1->livres[i].auteur, biblio1-
>livres[i].discipline) ;
}
}
 }
}

Int main() {
Bibliotheque biblio ;
initBibliotheque(&biblio, « Bibliothèque centrale », « Université de Paris ») ;
ajouterLivre(&biblio, « 001 », « Les Misérables », « Victor Hugo », « Roman ») ;
ajouterLivre(&biblio, « 002 », « L’Étranger », « Albert Camus », « Roman ») ;
ajouterLivre(&biblio, « 003 », « Le Petit Prince », « Antoine de Saint-Exupéry », « Roman
pour enfants ») ;
ajouterLivre(&biblio, « 004 », « Cours de physique de Feynman », « Richard P. Feynman »,
« Physique ») ;
ajouterLivre(&biblio, « 005 », « Le capital au XXIe siècle », « Thomas Piketty »,
« Économie ») ;
printf(« \nAfficher les livres de la bibliothèque:\n ») ;
afficherLivresBibliotheque(&biblio) ;
printf(« \nAfficher les livres d’une université:\n ») ;
afficherLivresUniversite(&biblio, « Université de Paris ») ;
printf(« \nAfficher toutes les bibliothèques d’une université:\n ») ;
afficherBibliothequesUniversite(&biblio, « Université de Paris ») ;
printf(« \nIntersection des livres de deux bibliothèques:\n ») ;
Bibliotheque biblio2 ;
initBibliotheque(&biblio2, « Bibliothèque des sciences », « Université de Paris ») ;
ajouterLivre(&biblio2, « 002 », « L’Étranger », « Albert Camus », « Roman ») ;
ajouterLivre(&biblio2, « 004 », « Cours de physique de Feynman », « Richard P. Feynman »,
« Physique ») ;
trouverIntersectionLivres(&biblio, &biblio2) ;
return 0 ;
}

On se donne la structure suivante :

struct traduction (char a ; char b ; } ;

On peut alors représenter un dictionnaire bilingue par un tableau de pointeurs de << struct
traduction >>, chaque case du tableau pointant sur une paire de mots se traduisant l’un en l’autre.
On supposera que les dictionnaires sont triés par ordre lexicographique (l’ordre alphabétique) sur le
champ a.

1. Écrire une fonction qui recherche le mot s dans les champ a du

dictionnaire dico (de tailleN), et renvoie en résultat sa traduction, ou
NULL si elle ne trouve pas s. Comme le Dictionnaire est supposé trié,
vous utiliserez une recherche dichotomique.
 2. On suppose que les données proviennent d’un fichier binaire contenant un ensemble
d’enregistrements de la forme de « struct traduction ». Écrire une fonction qui à
partir du fichier remplit le tableau de structures.

3. On voudrait maintenant créer une commande qui permet de rechercher un nom dans le
dictionnaire. Les arguments seront donnés sur la ligne de commande. Un exemple
d’exécution de la commande pourrait être celui donné ci-après :

Search nom dictio

Où << search » est le nom de la commande, «< nom » est le nom recherché, et « dictio >> est le Nom
du fichier ;

4. Ajouter une fonction main() qui teste les différentes fonctions.

Correction :

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define TAILLE_DICO 1000

Struct traduction {

Char a[20] ;

Char b[20] ;

};

/* ********Cette fonction prend en paramètres les arguments de la ligne de commande. Elle vérifie
que le nombre d’arguments est correct, puis récupère le nom du fichier et le mot à chercher. Elle
crée un tableau de traductions et le remplit à partir du fichier avec la fonction remplir_tableau().
Enfin, elle effectue une recherche dichotomique avec la fonction recherche_dichotomique() et
affiche le résultat.**********/

Struct traduction* recherche_dichotomique(struct traduction* dico, int taille, char* s) {

Int debut = 0 ;

Int fin = taille – 1 ;

While (debut <= fin) {

Int milieu = (debut + fin) / 2 ;

If (strcmp(dico[milieu].a, s) == 0) {

Return &dico[milieu] ;

} else if (strcmp(dico[milieu].a, s) < 0) {

 Debut = milieu + 1 ;

} else {

Fin = milieu – 1 ;

Return NULL ;

/***** Cette fonction prend en paramètres le tableau de traductions, sa taille et le nom du fichier
binaire à partir duquel remplir le tableau. Elle ouvre le fichier, lit les données avec la fonction fread()
et ferme le fichier.*******/

Void remplir_tableau(struct traduction* dico, int taille, const char* nom_fichier) {

FILE* fichier = fopen(nom_fichier, « rb ») ;

If ( !fichier) {

Perror(« Erreur lors de l’ouverture du fichier ») ;

Exit(EXIT_FAILURE) ;

Fread(dico, sizeof(struct traduction), taille, fichier) ;

Fclose(fichier) ;

Int main(int argc, char* argv[]) {

If (argc != 3) {

Fprintf(stderr, « Usage : %s nom_fichier mot\n », argv[0]) ;

Exit(EXIT_FAILURE) ;

Const char* nom_fichier = argv[1] ;

Const char* mot = argv[2] ;

Struct traduction dico[TAILLE_DICO] ;

Remplir_tableau(dico, TAILLE_DICO, nom_fichier) ;

Struct traduction* trad = recherche_dichotomique(dico, TAILLE_DICO, mot) ;

If (trad) {

Printf(« %s se traduit par %s\n », mot, trad->b) ;

 } else {

Printf(« %s non trouvé dans le dictionnaire\n », mot) ;

Return 0 ;

Exercise : map

#include <studio.h>

int* map(int (*f)(int),int *tab, int n)

int i ;

int* nv_tab = malloc(n*sizeof(int)) ;

for(i=0 ;i<n ;i++){

nv_tab[i] = f(tabIi]) ;

int carre(int X){

return X*X ;

int main(){

int i ;

int tab[]={1,2,3,4,5} ;

int n=5 ;

int* nvtab = map(carre,tab,n) ;

for(i=0 ;i<n ;i++){

printf (« %d \n », nvtab [i]) ;