Exercice 3 : Enregistrement

#include <stdio.h>
typedef struct { int JOURS_MAX(Date date) {
int jours; if (date.mois == 4 || date.mois ==
int mois; 6 || date.mois == 9 || date.mois ==
int annee; 11) {
} Date; return 30;
}
void SAISIE_DATE(Date *date) { return 31;
do { }
printf("Entrez le jour (1-31) : "); void DATE_DEMAIN(Date *date) {
scanf("%d", &date->jours); if (date->jours ==
} while (date->jours < 1 || date- JOURS_MAX(*date)) {
>jours > 31); date->jours = 1;
if (date->mois == 12) {
do { date->mois = 1;
printf("Entrez le mois (1-12) : "); date->annee++;
scanf("%d", &date->mois); } else {
} while (date->mois < 1 || date- date->mois++;
>mois > 12); }
} else {
do { date->jours++;
printf("Entrez l'annee (>= 1900) }
: "); }
scanf("%d", &date->annee); int main() {
} while (date->annee < 1900); Date date1, date2;
} printf("Saisie de la date 1 :\n");
void AFFICHE_DATE(Date date) { SAISIE_DATE(&date1);
printf("%02d/%02d/%d\n", printf("Saisie de la date 2 :\n");
date.jours, date.mois, date.annee); SAISIE_DATE(&date2);
}
int DATE_INFERIEURE(Date d1, Date printf("\nDate 1 : ");
d2) { AFFICHE_DATE(date1);
if (d1.annee < d2.annee) return 1; printf("Date 2 : ");
if (d1.annee > d2.annee) return 0; AFFICHE_DATE(date2);
if (d1.mois < d2.mois) return 1;
if (d1.mois > d2.mois) return 0; if (DATE_INFERIEURE(date1,
return d1.jours < d2.jours; date2)) {
}
 printf("La date 1 est plus printf("La date de demain de la
ancienne que la date 2.\n"); date 1 est : ");
} else { DATE_DEMAIN(&date1);
printf("La date 2 est plus AFFICHE_DATE(date1);
ancienne ou égale à la date 1.\n");
} return 0;
}

Exercice 4
#include <stdio.h> double
#include <math.h> moduleComplexe(Complexe z) {
typedef struct { return sqrt(z.reel * z.reel +
double reel; z.imaginaire * z.imaginaire);
double imaginaire; }
} Complexe; int main() {
Complexe Complexe c1, c2, somme,
sommeComplexe(Complexe a, produit;
Complexe b) { double moduleC1, moduleC2;
Complexe resultat; printf("Entrez le premier
resultat.reel = a.reel + b.reel; nombre complexe (partie reel
resultat.imaginaire = puis imaginaire) : ");
a.imaginaire + b.imaginaire; scanf("%lf %lf", &c1.reel,
return resultat; &c1.imaginaire);
} printf("Entrez le deuxième
Complexe nombre complexe (partie reel
produitComplexe(Complexe a, puis imaginaire) : ");
Complexe b) { scanf("%lf %lf", &c2.reel,
Complexe resultat; &c2.imaginaire);
resultat.reel = a.reel * b.reel - somme =
a.imaginaire * b.imaginaire; sommeComplexe(c1, c2);
resultat.imaginaire = a.reel * produit =
b.imaginaire + a.imaginaire * produitComplexe(c1, c2);
b.reel; moduleC1 =
return resultat; moduleComplexe(c1);
}
 moduleC2 = printf("Module de c1 :
moduleComplexe(c2); %.2lf\n", moduleC1);
printf("\nSomme : %.2lf + printf("Module de c2 :
%.2lfi\n", somme.reel, %.2lf\n", moduleC2);
somme.imaginaire); return 0;
printf("Produit : %.2lf + }
%.2lfi\n", produit.reel,
produit.imaginaire);

Chapitre : Liste chaînées

Une liste chaînée simple est une structure de données qui consiste en un
ensemble d'éléments, appelés nœuds, où chaque nœud contient une valeur et
une référence (ou un pointeur) vers le nœud suivant dans la séquence

Exemple 1 :
#include <stdio.h>
#include <stdlib.h>
//Déclaration de la structure du nœud :
typedef struct Node {
int data; // La valeur du nœud
struct Node* next; // Pointeur vers le prochain nœud
} Node;

//Fonction pour créer un nouveau nœud :

Node* creernoeud (int value) {
Node* newNode = (Node*) malloc(sizeof(Node));
if (!newNode) {
printf("Erreur: allocation de mémoire échouée\n");
exit(EXIT_FAILURE);
}
newNode->data = value;
newNode->next = NULL;
return newNode;
}
//Fonction pour ajouter un nœud à la fin de la liste chaînée :
void ajoutnoeud(Node** tete, int value) {
Node* newNode = creernoeud (value);
if (*tete == NULL) {
* tete = newNode;
return;
}
Node* temp = * tete;
while (temp->next != NULL) {
temp = temp->next;
}
temp->next = newNode;
}

//Fonction pour afficher la liste chaînée :

void afficher(Node* tete) {
Node* temp = tete;
while (temp != NULL) {
printf("%d -> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}

//Programme principal
int main() {
Node* tete = NULL;
ajoutnoeud (&tete, 10);
ajoutnoeud (&tete, 20);
ajoutnoeud (&tete, 30);
ajoutnoeud (&tete, 40);
afficher(tete);
return 0;
}

Exemple 2 :
#include <stdio.h>
#include <stdlib.h>
//Déclaration de la structure du nœud :
typedef struct Node {
int data; // La valeur du nœud
struct Node* next; // Pointeur vers le prochain nœud
} Node;

//Fonction pour créer un nouveau nœud :

Node* creernoeud (int value) {
Node* newNode = (Node*) malloc(sizeof(Node));
if (!newNode) {
printf("Erreur: allocation de mémoire échouée\n");
exit(EXIT_FAILURE);
}
newNode->data = value;
newNode->next = NULL;
return newNode;
}

//Fonction pour ajouter un nœud à la fin de la liste chaînée :

void ajoutnoeud(Node** tete, int value) {
Node* newNode = creernoeud (value);
if (*tete == NULL) {
* tete = newNode;
return;
}
Node* temp = * tete;
while (temp->next != NULL) {
temp = temp->next;
}
temp->next = newNode;
}

//Suppression d'un nœud à partir de sa valeur

void supprimer(Node** tete, int value) {
Node* temp = *tete;
Node* prev = NULL;

if (temp != NULL && temp->data == value) {

*tete = temp->next;
free(temp);
 return;
}

while (temp != NULL && temp->data != value) {

prev = temp;
temp = temp->next;
}
if (temp == NULL) return;
prev->next = temp->next;
free(temp);
}

//Libération de la mémoire (important pour éviter les fuites de mémoire)

void vider(Node* tete) {
Node* temp;
while (tete != NULL) {
temp = tete;
tete = tete->next;
free(temp);
}
}

//Fonction pour afficher la liste chaînée :

void afficher(Node* tete) {
Node* temp = tete;
while (temp != NULL) {
printf("%d -> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}

int main() {
Node* tete = NULL;

ajoutnoeud (&tete, 10);

ajoutnoeud (&tete, 20);
 ajoutnoeud (&tete, 30);
ajoutnoeud (&tete, 40);

afficher(tete);
supprimer(&tete, 20);
afficher(tete);
vider(tete);

return 0;
}

Liste chainée
Exercice 1
Question de cours :
Qu’est-ce qu’un pointeur ?
Un pointeur est une variable qui contient l'adresse mémoire d'une autre
variable. En d'autres termes, un pointeur pointe vers une position spécifique de
la mémoire où une autre valeur (ou variable) est stockée.
Différence entre statique et dynamique
Statique : Taille fixe, allocation de mémoire à la compilation, durée de vie
déterminée par la portée, localisation de la mémoire dans le segment statique.
Dynamique : Taille variable, allocation de mémoire à l'exécution, durée de vie
gérée manuellement.

Exercice
1)
typedef struct Node {
int data; // La valeur du nœud
struct Node* next; // Pointeur vers le prochain nœud
} Node;
Déclaration d'une variable de type Nœud (Node) qui représente le début de la
liste
Node* myList = NULL ;

2)
Exemple1
#include <stdio.h> current->data = arr[i];
#include <stdlib.h> current->next = NULL;
}
typedef struct Node { return tete;
int data; }
struct Node* next;
} Node; void afficherlistechainee(Node*
tete) {
Node* creerlistechainee(int arr[], int Node* temp = tete;
n) { while (temp != NULL) {
// Si le tableau est vide, printf("%d -> ", temp->data);
retourne NULL temp = temp->next;
if (n == 0) return NULL; }
printf("NULL\n");
Node* tete = (Node*) }
malloc(sizeof(Node));
if (!tete) { void libererespacelstchain(Node*
printf("Erreur: allocation de tete) {
mémoire échouée\n"); Node* temp;
exit(EXIT_FAILURE); while (tete != NULL) {
} temp = tete;
tete->data = arr[0]; tete = tete->next;
tete->next = NULL; free(temp);
}
Node* current = tete; }
for (int i = 1; i < n; i++) {
current->next = (Node*) int main() {
malloc(sizeof(Node)); int arr[] = {1, 2, 3, 4, 5};
if (!current->next) { int n = sizeof(arr) / sizeof(arr[0]);
printf("Erreur: allocation de Node* myList =
mémoire échouée\n"); creerlistechainee(arr, n);
exit(EXIT_FAILURE); afficherlistechainee(myList);
} libererespacelstchain(myList);
current = current->next; return 0;
}

Exemple 2 (ajout,supprimer)
#include <stdio.h> return tete;
#include <stdlib.h> }
typedef struct Node { void afficherliste(Node* tete) {
int data; Node* temp = tete;
struct Node* next; while (temp != NULL) {
} Node; printf("%d -> ", temp->data);
Node* creerliste(int arr[], int n) { temp = temp->next;
// Si le tableau est vide, }
retourne NULL printf("NULL\n");
if (n == 0) return NULL; }
void libererespaceliste(Node* tete) {
Node* tete = (Node*) Node* temp;
malloc(sizeof(Node)); while (tete != NULL) {
if (!tete) { temp = tete;
printf("Erreur: allocation de tete = tete->next;
mémoire échouée\n"); free(temp);
exit(EXIT_FAILURE); }
} }
tete->data = arr[0]; void
tete->next = NULL; supprimerNoeudparValeur(Node**
tete, int value) {
Node* current = tete; Node* temp = *tete;
for (int i = 1; i < n; i++) { Node* prev = NULL;
current->next = (Node*)
malloc(sizeof(Node)); // Si la tête de la liste contient la
if (!current->next) { valeur à supprimer
printf("Erreur: allocation de if (temp != NULL && temp->data
mémoire échouée\n"); == value) {
exit(EXIT_FAILURE); *tete = temp->next;
} free(temp);
current = current->next; return;
current->data = arr[i]; }
current->next = NULL; while (temp != NULL && temp-
} >data != value) {
 prev = temp; newNode->next = *tete;
temp = temp->next; *tete = newNode;
} }
if (temp == NULL) return;
prev->next = temp->next; int main() {
free(temp); int arr[] = {1, 2, 3, 4, 5};
} int n = sizeof(arr) / sizeof(arr[0]);
Node* myList = creerliste(arr, n);
void ajoutentete(Node** tete, int afficherliste(myList);
value) { ajoutentete(&myList, 0);
Node* newNode = (Node*) afficherliste(myList);
malloc(sizeof(Node));
if (!newNode) { supprimerNoeudparValeur(&myList,
printf("Erreur: allocation de 4);
mémoire échouée\n"); afficherliste(myList);
exit(EXIT_FAILURE); libererespaceliste(myList);
} return 0;
newNode->data = value; }

Comment rechercher un élément dans une liste chainée

#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node* next;
} Node;
Node* creerliste(int arr[], int n) {
// Si le tableau est vide,
retourne NULL
if (n == 0) return NULL;
Node* tete = (Node*)
malloc(sizeof(Node));
if (!tete) {
printf("Erreur: allocation de
mémoire échouée\n");
exit(EXIT_FAILURE);
} }
tete->data = arr[0];
tete->next = NULL;
Node* current = tete;
for (int i = 1; i < n; i++) {
current->next = (Node*)
malloc(sizeof(Node));
if (!current->next) {
printf("Erreur: allocation de
mémoire échouée\n");
exit(EXIT_FAILURE);
}
current = current->next;
current->data = arr[i];
current->next = NULL;
}
return tete;
void afficherliste(Node* tete) {
Node* temp = tete; void ajoutentete(Node** tete, int
while (temp != NULL) { value) {
printf("%d -> ", temp->data); Node* newNode = (Node*)
temp = temp->next; malloc(sizeof(Node));
} if (!newNode) {
printf("NULL\n"); printf("Erreur: allocation de
} mémoire échouée\n");
void libererespaceliste(Node* tete) { exit(EXIT_FAILURE);
Node* temp; }
while (tete != NULL) { newNode->data = value;
temp = tete; newNode->next = *tete;
tete = tete->next; *tete = newNode;
free(temp); }
} // Rechercher un élément x dans la
} liste chaînée
void int searchElement(Node* head, int
supprimerNoeudparValeur(Node** x) {
tete, int value) { Node* temp = head;
Node* temp = *tete; while (temp != NULL) {
Node* prev = NULL; if (temp->data == x) {
return 1; // Élément trouvé
// Si la tête de la liste contient la }
valeur à supprimer temp = temp->next;
if (temp != NULL && temp->data }
== value) { return 0; // Élément non trouvé
*tete = temp->next; }
free(temp);
return; int main() {
} int arr[] = {1, 2, 3, 4, 5};
while (temp != NULL && temp- int n = sizeof(arr) / sizeof(arr[0]);
>data != value) { Node* myList = creerliste(arr, n);
prev = temp; afficherliste(myList);
temp = temp->next; ajoutentete(&myList, 0);
} afficherliste(myList);
if (temp == NULL) return;
prev->next = temp->next; supprimerNoeudparValeur(&myList,
free(temp); 4);
} afficherliste(myList);
 int x = 3;
if (searchElement(myList, x)) {
printf("L'élément %d est
présent dans la liste.\n", x);
} else {
printf("L'élément %d n'est pas
présent dans la liste.\n", x);
}
libererespaceliste(myList);
return 0;
}