TD1 avec correction

Exercice 1
Écrire une fonction qui prend en paramètre une liste chaînée et renvoie une autre liste
ayant les mêmes éléments, mais dans l’ordre inverse.

Exercice 2
1. Écrire une fonction qui prend en paramètre une liste chaînée et une donnée, et
qui supprime la première occurrence de cette donnée dans la liste.
2. Écrire une fonction qui supprime toutes les occurrences d’une donnée (passée en
paramètre) dans une liste chaînée. Proposer deux version, une version itérative
et une version récursive.

Exercice 3 (Listes doublement chaînées)

On s’intéresse à des listes doublement chaînées, pour lesquelles chaque cellule à un
pointeur suiv vers la cellule suivante, et un pointeur preced vers la cellule précédente.
Voici un exemple ci-dessous :

1. Écrire une fonction de recopie d’une liste doublement chaînée à l’identique.

2. Écrire une fonction non conservative qui réalise la concaténation de deux listes
doublement chaînées.
3. Écrire une fonction d’insertion dans une liste triée doublement chaînée. La liste
doit rester triée.
4. Écrire une fonction qui supprime la première occurrence (si elle existe) d’un entier
dans une liste doublement chaînée.
5. Écrire une fonction qui supprime la dernière occurrence (si elle existe) d’un entier
dans une liste doublement chaînée.
6. Écrire une fonction qui supprime l’avant-dernière occurrence (si elle existe) d’un
entier dans une liste doublement chaînée.
7. Écrire une fonction qui supprime toutes les occurrences d’un nombre dans une
liste doublement chaînée.
 Correction

Exercice 1
Element *CreerListeEnvers(Element * L)
{
Element *p, *nouveauL = NULL;
p=L;
while (p != NULL)
{
nouveauL = insertDebut(p-> contenue, nouveauL);
p = p->suivant;
}
return nouveauL;
}
Exercice 2
Element* Supprime1occur(Element*L,int n){
Element *p, *suivant, *pl;
p=L;
if(p==NULL)
return L;
if(p->contenue==n)
{
pl=p->suivant;
free(p);
return pl;
}
suivant=p->suivant;
while(suivant->suivant!=NULL&&suivant->contenue!=n){
p=suivant;
suivant=suivant->suivant;
}
if(suivant->contenue==n)
{
p->suivant=suivant->suivant;
free(suivant);

}
return L;
}
------------------------------------------------------
Element* supprimertouteoccur(Element* L, int n)
{
if (L!=NULL)
{
if (L->contenue==n) {
 // si l'élément à enlever est en tête
Element *p=L->suivant;
free(L);
L= supprimertouteoccur(p, n);
} else {
L->suivant= supprimertouteoccur(L->suivant, n);
}
}
return L;
}

Element* supprimertouteoccur(Element* L, int n)

{
Element *p,*suivant,*pt;
p=L;
if(p==NULL)
return L;
if(p->contenue==n)
{
pt=p;
L=p->suivant;
free(pt);

}
p=L;
suivant=p->suivant;
while(suivant->suivant!=NULL)
{
if(suivant->contenue==n)
{
p->suivant=suivant->suivant;
free(suivant);
}
else
p=p->suivant;
suivant=p->suivant;
}
if(suivant->contenue==n)
{
p->suivant=NULL;
free(suivant);
}
return L;
}
Exercice 3
1.
Element * RecopieListe(Element * L)
{
Element *p, *nouveauL = NULL;
p=L;
while (p != NULL)
{
nouveauL = insereFin(nouveauL, p->contenue);
p = p->suivant;
}
return nouveauL;
}
---------------------------------------------------
2.
Element * ConcatenatDestruct(Element *L1, Element *L2)
{
Element *p;
p=L1;

if (L1==NULL)/* si L1 est vide */

return L2;

if (L2==NULL)/* si L2 est vide */

return L1;

while(p->suivant!=NULL)/* avancer jusque la fin de L1 */

p=p->suivant;
p->suivant=L2;
L2->precedent=p;
return L1;
}
-------------------------------------------------------------
3.
Element *InsereDonnee(Element *L,int donnee)
{
Element *precedent,*nouveau,*suivant;
nouveau=(Element*)malloc(sizeof(Element));
nouveau->contenue =donnee;

if (L==NULL)/* si la liste est vide */

{
nouveau->suivant=NULL;
nouveau->precedent=NULL;
return L;
}

else if (L->contenue >donnee)/* si l’élément à insérer est */

/*le plus petit élément de la liste */

/* et doit donc être insérer en tête */
{
nouveau->precedent=NULL;
nouveau->suivant=L;
L->precedent=nouveau;
return nouveau;
}

else/* dans tous les autres cas */

{

precedent=L;/* precedent est celui qui precède le suivant */

suivant=precedent->suivant;
while(suivant!=NULL && suivant->contenue <donnee)

/* tant que le suivant est plus petit que l’élément à */

/* insérer et tant qu’on n’est pas à la fin de la liste */
{
precedent=suivant;
suivant=suivant->suivant;
}

if (suivant==NULL)/*si l’élément à insérer est le dernier */

{
precedent->suivant=nouveau;
nouveau->precedent=precedent;
nouveau->suivant=NULL;
}
else
{
precedent->suivant=nouveau;
nouveau->precedent=precedent;
nouveau->suivant=suivant;
suivant->precedent=nouveau;
}
return L;
}
}
-----------------------------------------------------------
4.
Element *Supprime1occurence(Element *L,int n)
{
Element *precedent,*suivant,*p;
p=L;

if (p==NULL)/* si la liste est vide */

return L;

/* si la liste n’est pas vide */

while(p!=NULL && p->contenue!=n)/* tant qu’on n’est pas à
l’élément */

/* n recherché et tant qu’on est pas à la fin de la liste */

{

p=p->suivant;/* on avance dans la liste */

}

if (p!=NULL)/* si on a trouvé n */
{
precedent=p->precedent;
suivant=p->suivant;
free(p);

if (suivant!=NULL)/* si le suivant existe */

suivant->precedent=precedent;
if (precedent!=NULL)
precedent->suivant=suivant;

else/* precedent==NULL */
return suivant;
}
return L;
}
-------------------------------------------------------------
5.
Element *SupprimeDOccurence(Element *L,int n)
{
Element *precedent,*suivant,*p;
p=L;

if (p==NULL)/* si la liste est vide */

return L;

/* si la liste n’est pas vide */

while(p->suivant!=NULL)/* on avance jusqu’au dernier élement */
p=p->suivant;

/* on parcours la liste à partir de la fin jusqu’au début afin de supprimer la dernière

occurence de n */
while(p!=NULL && p->contenue!=n)/* tant qu’on est pas au élément */

/* n recherché et tant qu’on est pas au début de la liste */

{

p=p->precedent;/* on avance dans la liste */

}

if (p!=NULL)/* si on a trouvé n */
{
precedent=p->precedent;
suivant=p->suivant;
free(p);

if (suivant!=NULL)/* si le suivant existe */

suivant->precedent=precedent;
if (precedent!=NULL)
precedent->suivant=suivant;

else/* precedent==NULL */

return suivant;/* le premier élément de la liste a changé */

}
return L;
}
-----------------------------------------------------------
6.
Element *SupprimeAvantDerniere(Element *L,int n)
{
Element *precedent,*suivant,*p;
int compteur=0;/* sert à compter les occurrences de n. */
/* il sera égal à 2 à l’avant dernière */
/* occurrences de n en parcourant à l’envers */
p=L;
if (p==NULL)/* si la liste est vide */
return L;
/* si la liste n’est pas vide */
while(p->suivant!=NULL)/* on avance jusqu’au dernier élement */
p=p->suivant;
/* si la liste n’est pas vide, on parcourt à partir de la fin*/
while(p!=NULL)/* tant qu’on est pas à la fin de la liste */
{
if (p->contenue==n && compteur==0)
/* si on arrive à un élément égal à n avant compteur=2 */
compteur++;
else if (p->contenue==n && compteur==1)/* si on arrive au 2ème
n à partir de la fin*/
{
precedent=p->precedent;
suivant=p->suivant;
free(p);
if (suivant!=NULL)/* si le suivant existe */
suivant->precedent=precedent;
if (precedent!=NULL)
precedent->suivant=suivant;
else/* precedent==NULL */
return suivant;/* le premier élément a changé */
return L;
}
p=p->precedent;/* avancer au suivant */
}
return L;/* l’avant dernière occurence n’existe pas */
}
------------------------------------------------------
7.
Element *SupprimeTouteOccurence(Element *L,int n)
{
Element *precedent,*suivant,*p,*pfree;
p=L;

if (p==NULL)/* si la liste est vide */

return L;

/* si la liste n’est pas vide */

while(p!=NULL)/* tant qu’on est pas à la fin de la liste */
{

if (p->contenue==n)/* si on arrive à un élément égal à n */

{
precedent=p->precedent;
suivant=p->suivant;

if (suivant!=NULL)/* si le suivant existe */

suivant->precedent=precedent;
if (precedent!=NULL)
precedent->suivant=suivant;

else/* precedent==NULL */
L=suivant;

pfree=p;/* on mémorise la cellule à supprimer */

free(pfree);

p=suivant;/* avancer au suivant */

}
else

p=p->suivant;/* avancer au suivant */

}
return L;
}