int Existe(Liste L, int N) {

while (L != NULL) {
if (L->info == N) {
return 1; // La valeur existe dans la liste
}
L = L->suivant; // Passer à la cellule suivante
}
return 0; // La valeur n'existe pas dans la liste
}

int Existe(Liste L, int N) {

if (L == NULL) {
return 0; // La valeur n'existe pas dans la liste
}
if (L->info == N) {
return 1; // La valeur existe dans la liste
}
return Existe(L->suivant, N); // Appeler récursivement avec la sous-list
}

Liste Adresse1(Liste L, int N) {

while (L != NULL) {
if (L->info == N) {
return L; // Retourner l'adresse de la cellule contenant la valeur N
}
L = L->suivant; // Passer à la cellule suivante
}
 return NULL; // La valeur n'existe pas dans la liste
}

Liste Adresse1(Liste L, int N) {

if (L == NULL) {
return NULL; // La valeur n'existe pas dans la liste
}
if (L->info == N) {
return L; // Retourner l'adresse de la cellule contenant la valeur N
}
return Adresse1(L->suivant, N); // Appeler récursivement avec la sous-liste suivante
}

int NbOccurrences(Liste L, int N) {

int nbOcc = 0;
Cellule* courant = L;
while (courant != NULL) {
if (courant->info == N) {
nbOcc++;
}
courant = courant->suivant;
}
return nbOcc;
}

int NbOccurrences(Liste L, int N) {

if (L == NULL) {
return 0;
 } else {
if (L->info == N) {
return 1 + NbOccurrences(L->suivant, N);
} else {
return NbOccurrences(L->suivant, N);
}
}
}
int Max(Liste L) {
int max = L->info;
Cellule* courant = L->suivant;
while (courant != NULL) {
if (courant->info > max) {
max = courant->info;
}
courant = courant->suivant;
}
return max;
}
int Max(Liste L) {
if (L->suivant == NULL) {
return L->info;
} else {
int maxSuivant = Max(L->suivant);
if (L->info > maxSuivant) {
return L->info;
} else {
return maxSuivant;
 }
}
}
int Triee(Liste L) {
Cellule* courant = L;
while (courant != NULL && courant->suivant != NULL) {
if (courant->info > courant->suivant->info) {
return 0; // la liste n'est pas triée
}
courant = courant->suivant;
}
return 1; // la liste est triée
}

int Triee(Liste L) {
if (L == NULL || L->suivant == NULL) {
return 1; // cas de base : une liste vide ou à un seul élément est toujours triée
} else {
if (L->info > L->suivant->info) {
return 0; // la liste n'est pas triée
} else {
return Triee(L->suivant); // récursion sur le reste de la liste
}
}
}
void SupprimerTete(Liste *L) {
if (*L != NULL) {
Liste temp = *L;
*L = (*L)->suivant;
free(temp);
}
}

void SupprimerListe(Liste *L) {

while (*L != NULL) {
SupprimerTete(L);
}
}
void SupprimerValeur(Liste *L, int N) {
Liste courant = *L;
Liste precedent = NULL;

while (courant != NULL) {

if (courant->info == N) {
if (precedent == NULL) {
SupprimerTete(L);
courant = *L;
} else {
precedent->suivant = courant->suivant;
free(courant);
courant = precedent->suivant;
}
 } else {
precedent = courant;
courant = courant->suivant;
}
}
}

void SupprimerPos(Liste* L, int pos) {

if (pos < 1 || pos > Longueur(L)) {
printf("Position invalide\n");
return;
}

if (pos == 1) {
Liste* suivant = L->suivant;
free(L);
*L = *suivant;
}
else {
Liste* precedent = L;
Liste* courant = L->suivant;

for (int i = 2; i < pos; i++) {

precedent = courant;
courant = courant->suivant;
}
precedent->suivant = courant->suivant;
free(courant);
 }
}
void Fusion(Liste L1, Liste L2, Liste *L3) {
while (L1 != NULL && L2 != NULL) {
if (L1->info <= L2->info) {
InsererQueue(L3, L1->info);
L1 = L1->suivant;
} else {
InsererQueue(L3, L2->info);
L2 = L2->suivant;
}
}

while (L1 != NULL) {

InsererQueue(L3, L1->info);
L1 = L1->suivant;
}

while (L2 != NULL) {

InsererQueue(L3, L2->info);
L2 = L2->suivant;
}
}
void Eclater(Liste L, Liste* L1, Liste* L2) {
*L1 = NULL; // Initialisation de la liste L1
*L2 = NULL; // Initialisation de la liste L2

while (L != NULL) { // Parcours de la liste L

 if (L->info % 2 == 0) {
InsererQueue(L2, L->info); // Insertion en queue dans L2 si l'élément est pair
} else {
InsererQueue(L1, L->info); // Insertion en queue dans L1 si l'élément est impair
}
L = L->suivant; // Passage à l'élément suivant de L
}
}
void Inverser(Liste* L) {
if (*L == NULL || (*L)->suivant == NULL) { // Cas de base : la liste est vide ou ne
contient qu'un élément
return;
}

Liste L1 = (*L)->suivant; // L1 contient la suite de la liste L à partir du deuxième

élément
Inverser(&L1); // Inversion récursive de L1
InsererQueue(&L1, (*L)->info); // Insertion en queue du premier élément de L dans
L1
*L = L1; // Mise à jour de la liste L
}