Les listes chaînées

typedef struct element
{
    MonType valeur;          //valeur de l'élément
    Element* suivant;       // Pointeur vers le tableau des éléments
}
Element;  

int IsListeVide (Element* pListe) 
{
    if (pListe == NULL)    // Si la liste est NULL:
        return 1;               // c'est qu'elle est vide
                           // Dans le cas contraire
    return 0;                   // c'est FAUX: elle n'est pas vide
}

int NbreElements(Element* pListe) 
{
    int compt=0;                                // Initialise un compteur d'élément
 
    if (IsVideListe)                            // Si la liste est vide:
        return 0;                                    // zéro élément!
 
    Element* pTemp = malloc(sizeof(Element));   // élément de parcours de liste
 
    pTemp = pListe;                             // Initialisation à la tête de liste
 
    while (pTemp->suivant != NULL)              // Parcours de la liste
    {
        pTemp = pTemp->suivant;                      // Décalage dans la liste 
        compt++;                                     // Ajout de l'élément au compteur
    }
    return compt;                               // Renvoi le compte
} 

void InsertionListeSimplementChainee(Element* pListe, Element* pNouv) 
{
    /* Si l'élément doit être inséré en début
     * de liste ou que la liste est vide.... */
    if (isAvant(pNouv, pListe) || pListe==NULL) 
    {
        /* l'élément est inséré */	
        pNouv->suivant=pListe;   // Création du lien 1
        pListe=pNouv;            // Récupération du début de liste
        return;
    }
 
    /* si l'on arrive là, il va falloir parcourir
       la liste à la recherche de l'emplacement où
       insérer l'élément. Il va donc falloir créer
       un élément temporaire de parcours de liste...   */
    Element* pTemp=malloc(sizeof(Element));
    /* ..prenant la valeur de la tete de liste */
    pTemp=pListe;
 
    /* tant que la condition n'est pas atteinte
     * et que la liste n'est pas terminée  .... */
    while (pTemp->suivant!=NULL && !isAvant(pNouv,pTemp->suivant))
    {
        /* ...parcours de la liste */
        pTemp=pTemp->suivant;
    }    
    /* Insertion du nouvel élément */
    pNouv->suivant=pTemp->suivant;  // Création du lien 1
    pTemp->suivant=pNouv;           // Création du lien 2	
    return;
}

#include 
void SupprimerElementListeSimplementChainee(Element* pListe, Element* pElement) 
{
    if (pListe==NULL) {                // Si la liste est vide...
        return;                            // ...la fonction ne sert à rien!
    }
    if (pListe == pElement)            // Si l'élément est en début de liste...
    {         
        pListe = pElement->suivant;        // Suppression de la liste
        free(pElement);                    // Suppression de l'élément
        return;                            // Fin
    }
    /* si l'on arrive là, il va falloir parcourir  *
     * la liste à la recherche de l'élément Il va  *
     * donc falloir créer un élément temporaire de *
     * parcours de liste...                        */
    Element* pTemp=malloc(sizeof(Element));
    /* ..prenant la valeur de la tete de liste     */
    pTemp=pListe;
    /* tant que l'élément n'est pas atteint        *
     * et que la liste n'est pas terminée  ....    */
    while (pTemp->suivant!=NULL && pElement!=pTemp->suivant))
    {
        /* ...parcours de la liste */
        pTemp=pTemp->suivant
    }
    pTemp->suivant=pElement->suivant;  // Supprime l'élément de la liste 
    free(pElement);                    // Supprime l'élément
    return;
}

typedef struct element
{
    MonType valeur;      //valeur de l'élément
    Element *suivant;    // Pointeur vers l'élément suivant dans la liste
    Element *precedent;  // Pointeur vers l'élément précédent dans la liste
}
Element;

void InsertionListeDoublementChainee(Element* pListe, Element* pNouv) 
{
    /* Si l'élément doit être inséré en début
     * de liste ou que la liste est vide.... */
    if (isAvant(pNouv, pListe) || pListe==NULL) 
    {
        /* l'élément est inséré */	
        pNouv->suivant = pListe;   // Création du lien 1
        pListe->precedent = pNouv; // Création du lien 4
        pListe = pNouv;            // Récupération du début de liste
        return;
    }
 
    /* si l'on arrive là, il va falloir parcourir
       la liste à la recherche de l'emplacement où
       insérer l'élément. Il va donc falloir créer
       un élément temporaire de parcours de liste...   */
    Element* pTemp=malloc(sizeof(Element));
    /* ..prenant la valeur de la tete de liste */
    pTemp=pListe;
 
    /* tant que la condition n'est pas atteinte
     * et que la liste n'est pas terminée  .... */
    while (pTemp->suivant!=NULL && !isAvant(pNouv,pTemp->suivant))
    {
        /* ...parcours de la liste */
        pTemp=pTemp->suivant;
    }    
    /* Insertion du nouvel élément */
    pNouv->suivant=pTemp->suivant;     // Création du lien 1
    pTemp->suivant=pNouv;              // Création du lien 2
    pNouv->precedent = pTemp           // Création du lien 3
    pNouv->suivant->precedent = pNouv  // Création du lien 4
    return;
}