TD : Listes chaînées

Partie 1 : Parcourir une liste chaînée

On considère la structure suivante :
typedef struct nœud { float nbr ;
struct nœud * suivant ; } nœud ;

1. Ecrire la fonction : vide (L), et qui retourne 1 si liste chaînée L n’est pas vide, sinon 0.

2. Ecrire la fonction : sommet (L), qui retourne la valeur du premier élément de la liste
chaînée L non vide.

3. Ecrire la fonction : imprime (L), qui affiche les éléments de la liste chaînée L.

4. Ecrire la fonction : taille (L), qui compte le nombre d’éléments de la liste chaînée L.

5. Ecrire la fonction : somme (L), qui calcule la somme des éléments de la liste chaînée L.

6. Ecrire la fonction : moyenne (L), qui calcule la moyenne des éléments de la liste
chaînée L non vide.

7. Ecrire la fonction : recherche (x , L), qui recherche un réel x dans la liste chaînée L, et
retourne 1 si x se trouve dans la liste, sinon 0.

8. Ecrire la fonction : occurrence (x, L), qui calcule l’occurrence d’un réel x dans la liste
chaînée L.

9. Ecrire la fonction : max (L), qui retourne le maximum des éléments de la liste chaînée L
non vide.

10. Ecrire la fonction : premPosMax (L), qui retourne la première position du maximum de
la liste chaînée L non vide.

11. Ecrire la fonction : derPosMax (L), qui retourne la dernière position du maximum de la
liste chaînée L non vide.

12. Ecrire la fonction : valeur (n, L), qui retourne la valeur du nombre qui se trouve à la
position n de la liste chaînée L non vide. (on suppose que : 1<= n <= nombre d’élément de
la liste L)

13. Ecrire la fonction : queue (L), qui retourne la valeur du dernier élément de la liste
chaînée L non vide.

14. Ecrire la fonction : adresse (n , L), qui retourne l’adresse de l’élément qui se trouve à la
position n de la liste chaînée L. Si la position n n’existe pas dans la liste L, la fonction doit
retourner NULL.

15. Ecrire la fonction : croissante (L), qui retourne 1 si les éléments de la liste chaînée L
sont rangés en ordre croissant, 0 sinon.

16. Ecrire la fonction : trie (L), qui trie la liste chaînée L, dans l’ordre décroissant.

17. Ecrire toutes les fonctions précédentes pour une liste chaînée circulaire
1
 CORRECTION  : Parcourir de liste chaînée
1-------------------------------------------- int recherche (float x , nœud * L)
int vide (nœud * L) { if (L==NULL) return 0 ;
{ if (L==NULL) return 0 ; else if (x==L->nbr) return 1 ;
return 1 ; else return recherche (x , L->suivant) ;
} }
2--------------------------------------------
float sommet ( nœud * L) 8--------------------------------------------
{ return L->nbr ; int occurrence (float x , nœud * L)
} { noeud * q ; int c=0 ;
3-------------------------------------------- for (q=L ; q!=NULL ; q=q->suivant)
void imprime (nœud * L) { if (x==q->nbr) c++ ; }
{ nœud * q ;   return c ;
for (q=L ; q!=NULL ; q=q->suivant) }
{ printf ("%f\n",q->nbr) ; }
} int occurrence (float x , nœud * L)
{ if (L==NULL) return 0 ;
void imprime (nœud * L) else if (x==L->nbr)
{ if (L !=NULL) return 1 + occurrence (x , L->suivant) ;
{ printf ("%f\n",L->nbr) ; else return occurrence (x , L->suivant) ;
imprime(L->suivant) ; }
} 9--------------------------------------------
} float max ( nœud * L)
4-------------------------------------------- { float m=L->nbr ;
int taille (nœud * L) noeud * q ;  
{ noeud * q ; int c=0 ; for (q=L ; q!=NULL ; q=q->suivant)
for (q=L ; q!=NULL ; q=q->suivant) { if (m < q->nbr) m = q->nbr  ; }
{ c++ ; }   return m ;
  return c ; }
} 10--------------------------------------------
int premPosMax ( nœud * L)
int taille (noeud * L) { float m=max(L) ;
{ if (L==NULL) return 0 ; noeud * q ;   int c=1 ;
else return 1+ taille (L->suivant) ; for (q=L ; q!=NULL ; q=q->suivant)
} { if (m==q->nbr) return c ;
5------------------------------------------- c++ ; }
float somme (nœud * L) }
{ noeud * q ; float S=0 ; 11--------------------------------------------
for (q=L ; q!=NULL ; q=q->suivant) int derPosMax ( nœud * L)
{ S=S+q->nbr ; } { float m=max(L) ;
  return S ; noeud * q ; int c=1, p ;
} for (q=L ; q!=NULL ; q=q->suivant)
{ if (m==q->nbr) p=c ;
float somme (noeud * L) c++ ; }
{ if (L==NULL) return 0 ; return p ;
else return L->nbr + somme (L->suivant) ; }
} 12--------------------------------------------
6-------------------------------------------- float valeur ( int n , nœud * L)
float moyenne (noeud * L) { noeud * q ; q=L ; 
{ float m ; int i ;
m=somme(L)/taille(L) ; for (i=1 ; i<n , i++)
return m ; { q=q->suivant ; }
} return q->nbr ;
7-------------------------------------------- }
int recherche (float x , nœud * L) 13--------------------------------------------
{ noeud * q ;   float queue ( nœud * L)
for (q=L ; q!=NULL ; q=q->suivant) { return valeur (taille(L) , L) ;
{ if (x==q->nbr) return 1 ; } }
  return 0 ;
}

2
14-------------------------------------------- int recherche (float x , nœud * L)
nœud * adresse ( int n , nœud * L) { noeud * q ; q=L;
{ if (n<1 || n>taille(L)) return NULL ; int i ;
noeud * q ; q=L ;  for (i=1 ; i<=taille(L) ; i++)
int i ; { if (x==q->nbr) return 1 ;
for (i=1 ; i<n , i++) q=q->suivant ; }
{ q=q->suivant ; } return 0 ;
return q ; }
}
15-------------------------------------------- int occurrence (float x , nœud * L)
int croissante ( nœud * L) { noeud * q ; int c=0 ;
{ noeud * q ; q=L ;  int i ; q=L;
while (q!=NULL && q->suivant !=NULL) for (i=1 ; i<=taille(L) ; i++)
{ if (q->nbr > q->suivant->nbr) return 0 ; { if (x==q->nbr) c++ ;
q=q->suivant ; } q=q->suivant ; }
return 1 ; return c ;
} }
16--------------------------------------------
nœud * trie (nœud * L) float max ( nœud * L)
{ nœud * p , * q ; int x ; { float m=L->nbr ;
for (p=L ; p!=NULL ; p=p->suivant) noeud * q ; q=L ; 
for (q=p->suivant ; q !=NULL ; q=q->suivant) int i ;
if (p->nbr > q->nbr) for (i=1 ; i<=taille(L) ; i++)
{ x=p->nbr ; { if (m < q->nbr) m = q->nbr  ;
p->nbr=q->nbr ; q=q->suivant ; }
q->nbr=x ;   return m ;
} }
return L ;
} int premPosMax ( nœud * L)
17--------- Liste circulaire ------------- { float m=max(L) ;
int taille (nœud * L) noeud * q ;
{ noeud * q ; int c=0 ; int i ; q=L;
if (L !=NULL) for (i=1 ; i<=taille(L) ; i++)
{ c=1 ; { if (m==q->nbr) return i ;
q=L->suivant ;  q=q->suivant ; }
while (q!=L) }
{ c++ ;
q=q->suivant ; } int derPosMax ( nœud * L)
} { float m=max(L) ;
  return c ; noeud * q ;
} int i ; q=L; int p ;
for (i=1 ; i<=taille(L) ; i++)
void imprime (nœud * L) { if (m==q->nbr) p=i ;
{ nœud * q ; q=L ;  q=q->suivant ; }
int i ; return p ;
for (i=1 ; i<=taille(L) ; i++) }
{ printf ("%f\n",q->nbr) ;
q=q->suivant ; } nœud * trie (nœud * L)
} { if (L==NULL || L->suivant==L) return L ;
nœud * p , * q ;
float somme (nœud * L) p=L ; int x ;
{ noeud * q ; float S=0 ; while (p->suivant!=L)
int i ; q=L; { q=p->suivant ;
for (i=1 ; i<=taille(L) ; i++) while (q!=L)
{ S=S+ q->nbr ; { if (p->nbr > q->nbr)
q=q->suivant ; } { x=p->nbr ;
  return S ; p->nbr=q->nbr ;
} q->nbr=x ;
}
q=q-> suivant ;
}
p=p->suivant ;
}
return L ;
}

3
 TD : Listes chaînées
Partie 2 : Ajouter un élément dans une liste chaînée
Exercice1 :
On considère la structure suivante :
typedef struct element { float nbr ;
struct element * suivant ; } element ;
typedef element * LstNbr ;

1. Ecrire la fonction : LstNbr ajoutD (float x, LstNbr L) qui ajoute un nouvel élément de
valeur x au début de la liste chainée L.

2. Ecrire la fonction : LstNbr ajoutF (float x, LstNbr L) qui ajoute un nouvel élément de
valeur x à la fin de la liste chainée L non vide.

3. Ecrire la fonction : LstNbr insere (float x, int n , LstNbr L) qui insère un nouvel élément
de valeur x à la position n de la liste chainée L. (On suppose que 1<=n<=taille(L))

4. Ecrire la fonction : LstNbr ajSansDoublant (float x, LstNbr L) qui ajoute un nouvel

élément de valeur x à la fin de la liste chainée L, si x n’existe pas dans la liste.

5. Ecrire la fonction : LstNbr insereT (float x, LstNbr L) qui insère un nouvel élément de
valeur x dans la liste chainée L non vide, triée par ordre croissant.

Exercice 2 :
On considère la structure suivante :
typedef struct maillon { float nbr ;
int occurrence ;
struct maillon * suivant ;
} maillon ;
typedef maillon * LstReel ;

Ecrire la fonction : LstReel ajout (float x, LstReel L), qui ajoute un nouvel élément de valeur
x dans la liste chainée L non vide, et ne contenant pas de doublons : si le nombre x se
trouve dans la liste, son occurrence sera incrémentée de 1, sinon l’ajout sera à la fin de la
liste

Exercice 3 : Liste circulaire

On considère la structure de l’exercice 1

1. Ecrire la fonction : LstNbr ajoutD (float x, LstNbr L) qui ajoute un nouvel élément de
valeur x au début de la liste chainée circulaire L.

2. Ecrire la fonction : LstNbr ajoutF (float x, LstNbr L) qui ajoute un nouvel élément de
valeur x à la fin de la liste chainée circulaire L non vide.

4
 CORRECTION  : Ajouter un élément dans une liste chaînée
Exercice 1 : p->next=q->next ;
1----------------------------------------------------------- q->next=p ;
LstNbr ajoutD (float x , LstNbr L) return L ;
{ LstNbr p  ; }
p=malloc(sizeof(element)) ;
p->nbr=x ; Exercice 2 :
p->suivant=L ; LstReel recherche (float x , LstReel L)
return p ; // ou L=p ; return L ; { LstReel q ;  
} for (q=L ; q!=NULL ; q=q->suivant)
{ if (x==q->nbr) return q ; }
2-----------------------------------------------------------   return NULL ; // ou return q ;
LstNbr ajoutF (float x, LstNbr L) }
{ LstNbr p ;
p=malloc(sizeof(element)) ; LstReel ajoutF (float x, LstReel L)
p->nbr=x ; { LstReel p ;
p->suivant=NULL ; p=recherche (x,L) ;
LstNbr q ; q=L ; if (p !=NULL)
while (q->suivant !=NULL) { q=q->suivant ; } { p->occurrence=p->occurrence + 1 ;
q->suivant=p ; return L ;
return L ; }
} p=malloc(sizeof(element)) ;
p->nbr=x ; p->occurrence=1 ;
3----------------------------------------------------------- p->suivant=NULL ;
LstNbr insere (float x, int n , LstNbr L) LstReel q ; q=L ;
{ if (k==1) { L= ajoutD (x,L) ; while (q->suivant !=NULL) { q=q->suivant ; }
return L ; } q->suivant=p ;
LstNbr p ; return L ;
p=malloc(sizeof(element)) ; }
p->nbr=x ;
LstNbr q ; Exercice 3 : Liste circulaire
q=L ; int i ; 1-----------------------------------------------------------
for (i=1 ; i<n-1 ; i++) LstNbr ajoutD (float x , LstNbr L)
{ q=q->suivant ; } { LstNbr P ;
p->suivant=q->suivant ; p=malloc(sizeof(element)) ;
q->suivant=p ; p->nbr=x ;
return L; if (L==NULL)
} { L=P ;
L->suivant=L ;
4----------------------------------------------------------- return L ; }
int recherche (float x , LstNbr L) LstNbr q ; q=L;
{ LstNbr q ;   while (q->suivant !=L) { q=q->suivant ; }
for (q=L ; q!=NULL ; q=q->suivant) p->suivant =L ;
{ if (x==q->nbr) return 1 ; } q->suivant=p;
  return 0 ; L=p ;
} return L ;
}
LstNbr ajSansDoublant (float x, LstNbr L)
{ if (recherche(x,L)==1 return L; 2-----------------------------------------------------------
else return ajoutF (x,L) ; LstNbr ajoutF (float x , LstNbr L)
} { L=ajoutD (x,L) ;
L=L->suivant ;
5----------------------------------------------------------- return L ;
LstNbr insereT (float x, LstNbr L) }
{ if (x<=L->nbr) { L= ajoutD (x,L) ;
return L ; }
LstNbr p ;
p=malloc(sizeof(element)) ;
p->val=x ;
LstNbr q ; q=L ;
while(q->next!=NULL && x>q->next->nbr)
{ q=q->next ; }

5
 TD : Listes chaînées
Partie 3 : Supprimer un élément dans une liste chaînée