[C] Bibliothèque de gestion des listes doublement chainées

[InstinctHack]

Premier code en C :
Elle seras complété par la suite et suivie d'autres
(je pense améliorer ce code pour gerer une arborescence de fichier, donc des structures de arborescence, de répertoire et de fichier...)
Vive le partage

Code :

#include "../h/listes_chaine_simple.h"

typedef struct Node Node;
struct Node
{
    int nombre;
    Node *p_node_suivant;
    Node *p_node_precedant;
};

typedef struct Liste Liste;
struct Liste
{
    Node *p_node_premier;
    Node *p_node_dernier;
    int longueur;
    char name[100];
};

Liste *listes_chaine_simple_initialisation()
{
    Liste *p_liste = malloc(sizeof(*p_liste));

    if (p_liste == NULL)
    {
        printf("Memoire insuffisante! Fin du programme!");
        exit(EXIT_FAILURE);
    }
    else
    {
        p_liste->longueur=0;
        p_liste->p_node_premier=NULL;
        p_liste->p_node_dernier=NULL;
    }
    return p_liste;
}

void listes_chaine_simple_afficher(Liste *p_liste)
{
    if (p_liste == NULL)
    {
        exit(EXIT_FAILURE);
    }
    else
    {
        Node *p_node_actuel = p_liste->p_node_premier;
        printf("Parcours de la liste de longueur : %d\n",p_liste->longueur);
        while (p_node_actuel != NULL)
        {
                printf("\tA l'adresse %p contient :\n\t\t%p node precedant\n\t\t%p node suivant\n\t\t%d data\n",p_node_actuel,p_node_actuel->p_node_precedant,p_node_actuel->p_node_suivant,p_node_actuel->nombre);
                p_node_actuel = p_node_actuel->p_node_suivant;
        }
        printf("\nFin du parcours\n");
    }
}

void listes_chaine_simple_append(Liste *p_liste,char * position, int nombre)
{
    if (p_liste != NULL) /* On vérifie si notre liste a été allouée */
    {
        Node *p_node_new = malloc(sizeof(*p_node_new));/* Création d'un nouveau node */
        if (p_node_new == NULL) /* On vérifie si le malloc n'a pas échoué */
        {
            exit(EXIT_FAILURE);
        }
        else
        {
            p_node_new->nombre = nombre; /* On 'enregistre' notre donnée */

            if(position=="append"){
                p_node_new->p_node_suivant = NULL; /* On fait pointer p_next vers NULL */
            } else if(position=="prepend"){
                p_node_new->p_node_precedant = NULL; /* On fait pointer p_precedant vers NULL */
            }else    {exit(EXIT_FAILURE);}


            if (p_liste->longueur == 0) /* Cas où notre liste est vide (pointeur vers fin de liste à  NULL) */
            {
                if(position=="append"){
                    p_node_new->p_node_precedant = NULL; /* On fait pointer p_prev vers NULL */
                } else if(position=="prepend"){
                    p_node_new->p_node_suivant = NULL;
                }else    {exit(EXIT_FAILURE);}
                p_liste->p_node_premier = p_node_new; /* On fait pointer la tête de liste vers le nouvel élément */
                p_liste->p_node_dernier = p_node_new; /* On fait pointer la fin de liste vers le nouvel élément */
            }
            else /* Cas où des éléments sont déjà présents dans notre liste */
            {
                if(position=="append"){
                    p_liste->p_node_dernier->p_node_suivant = p_node_new; /* On relie le dernier élément de la liste vers notre nouvel élément (début du chaînage) */
                    p_node_new->p_node_precedant = p_liste->p_node_dernier; /* On fait pointer p_prev vers le dernier élément de la liste */
                    p_liste->p_node_dernier = p_node_new; /* On fait pointer la fin de liste vers notre nouvel élément (fin du chaînage: 3 étapes) */

                } else if(position=="prepend"){
                    p_liste->p_node_premier->p_node_precedant = p_node_new;
                    p_node_new->p_node_suivant = p_liste->p_node_premier;
                    p_liste->p_node_premier = p_node_new;
                }else    {exit(EXIT_FAILURE);}


            }
            p_liste->longueur++; /* Incrémentation de la taille de la liste */
        }
    }
}

void liste_chaine_simple_insert(Liste *p_liste, int position, int nombre)
{
    if (p_liste == NULL)
    {
        exit(EXIT_FAILURE);
    }
    else
    {
        if(position==0)
        {
//            printf("\nfacile prepend!\n");
            listes_chaine_simple_append(p_liste,"prepend",nombre);
        }
        else if(position==((p_liste->longueur)-1))
        {
//            printf("\nfacile append!\n");
            listes_chaine_simple_append(p_liste,"append",nombre);
        }
        else
        {
//            printf("\ndur search :'( \n");
            Node *p_node_temp = p_liste->p_node_premier;/* Création d'un nouveau node */
            int i = 0;
            while (p_node_temp != NULL && i <= position)
            {
                if (position == i)
                {
/*
                    if (p_node_temp->p_node_suivant == NULL)
                    {
                        listes_chaine_simple_append(p_liste,"append",nombre);
                    }
                    else if (p_node_temp->p_node_precedant == NULL)
                    {
                        listes_chaine_simple_append(p_liste,"prepend",nombre);
                    }

                    else
                    {
*/
                        Node *p_node_new = malloc(sizeof(*p_node_new));/* Création d'un nouveau node */
                        if (p_node_new == NULL)
                        {
                            exit(EXIT_FAILURE);
                        }
                        else
                        {
                            p_node_new->nombre = nombre;
                            p_node_temp->p_node_suivant->p_node_precedant = p_node_new;
                            p_node_temp->p_node_precedant->p_node_suivant = p_node_new;
                            p_node_new->p_node_precedant = p_node_temp->p_node_precedant;
                            p_node_new->p_node_suivant = p_node_temp;
                            p_liste->longueur++;
                        }
//                    }
                }
                else
                {
                    p_node_temp = p_node_temp->p_node_suivant;
                }
                i++;
            }
        }
    }
}

void liste_chaine_simple_delete_id(Liste *p_liste,int position)
{
    if (p_liste == NULL)
    {
        exit(EXIT_FAILURE);
    }
    else
    {
        Node *p_node_temp = p_liste->p_node_premier;
        int i = 0;
        while (p_node_temp != NULL && i <= position)
        {
            if (position == i)
            {
                if (p_node_temp->p_node_suivant == NULL && p_node_temp->p_node_precedant == NULL)
                {
                    p_liste->p_node_dernier = NULL;
                    p_liste->p_node_premier = NULL;
                }
                else if (p_node_temp->p_node_suivant == NULL)
                {
                    p_liste->p_node_dernier = p_node_temp->p_node_precedant;
                    p_liste->p_node_dernier->p_node_suivant = NULL;
                }
                else if (p_node_temp->p_node_precedant == NULL)
                {
                    p_liste->p_node_premier = p_node_temp->p_node_suivant;
                    p_liste->p_node_premier->p_node_precedant = NULL;
                }
                else
                {
                    p_node_temp->p_node_suivant->p_node_precedant = p_node_temp->p_node_precedant;
                    p_node_temp->p_node_precedant->p_node_suivant = p_node_temp->p_node_suivant;
                }
                free(p_node_temp);
                p_liste->longueur--;
            }
            else
            {
                p_node_temp = p_node_temp->p_node_suivant;
            }
            i++;
        }
    }
}

void liste_chaine_simple_delete(Liste *p_liste)
{
    while(p_liste->longueur>1)
    {
        liste_chaine_simple_delete_id(p_liste,0);
    }
    free(p_liste);
}

[supersnail]

Hum, en gros t'as fait une sorte de liste doublement chaînée améliorée :p (après je sais pas si ça sert vraiment le champ p_node_dernier de la structure Liste).

Bref, sympa, même si ton post m'a fait rater le leet time :').