Liste Doublement chaînée, gestion de pile

Bien le bonjour, je coince un petit peu dans le labo que je dois rendre pour lundi, je l'ai bouclé en grande partie.

Le labos consiste en:

Création de la liste (en mode pile ou file non imposé)
Ajout en mode pile à partir du pointeur de base
Ajout en mode pile à partir du pointeur de fin
Affichage de la liste du pointeur de base au pointeur de fin
Affichage de la liste du pointeur de fin au pointeur de base
Vidange de la liste (avec libération de la mémoire).

C'est ce dernier point qui me pose sous, lorsque je l'effectue et que je relance un affichage après, ça coince...
Il me renvois X fois la même adresse... X étant = au nombre de valeur introduite dans la pile.

Voici mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct UneCellule {
    int UnEntier;
    struct UneCellule *Precedent;
    struct UneCellule *Suivant;
}ListeDEntiers;
 
ListeDEntiers *CreerPile(int, ListeDEntiers *, ListeDEntiers **);
ListeDEntiers *AjoutBase(int, ListeDEntiers *);
ListeDEntiers *AjoutFin(int, ListeDEntiers *);
void LitPile(ListeDEntiers *);
void LitPileInverse(ListeDEntiers *);
void SupressionLiberation(ListeDEntiers *);
 
ListeDEntiers *PBase;
ListeDEntiers *PFin;
 
 
main() {
    PBase=NULL;
    PFin=NULL;
    char n[10];
    int Choix, Valeur, N;
    do {
        printf("\n\n");
        printf("1 - Creation liste\n");
        printf("2 - Ajout d'element a la base de la liste\n");
        printf("3 - Ajout d'element a la fin de la liste\n");
        printf("4 - Affichage a partir de la base\n");
        printf("5 - Affichage a partir de la fin\n");
        printf("6 - Suppression et Liberation\n");
        printf("0 - Fin\n");
        printf("\n Choix ? ");
        scanf("%d",&Choix);
        getc(stdin);
        switch(Choix) {
            case 1: if((PBase && PFin)!=NULL) {
                        printf("\nIl y  deja une liste");
                    } else {
                        printf("\nEncoder une valeur : ");
                        gets(n);
                        while (strlen(n)>0) {
                            Valeur=atoi(n);
                            PBase=CreerPile(Valeur, PBase, &PFin);
                            printf("\nEncoder une nouvelle valeur : ");
                            gets(n);
                        }
                    }
                break;
            case 2: printf("\n Valeur a encoder? ");
                    gets(n);
                    if (strlen(n)>0) {
                        Valeur=atoi(n);
                        PBase=AjoutBase(Valeur, PBase);
                    }
                break;
            case 3: printf("\nValeur a encoder? ");
                    gets(n);
                    if (strlen(n)>0) {
                        Valeur=atoi(n);
                        PFin=AjoutFin(Valeur, PFin);
                    }
                break;
            case 4: LitPile(PBase);
                break;
            case 5: LitPileInverse(PFin);
                break;
            case 6: SupressionLiberation(PBase);
                break;
            default: printf("\n\tMauvais choix, meme joueur joue encore!!\n");
        }
    }
    while(Choix != 0);
    printf("\n\n");
    system("Pause");
    return 0;
}
 
ListeDEntiers *CreerPile(int Valeur, ListeDEntiers *ptr, ListeDEntiers **PFin) {
    ListeDEntiers *PTrav;
    PTrav=malloc(sizeof(ListeDEntiers));
    PTrav->UnEntier=Valeur;
    PTrav->Suivant=ptr;
    if(*PFin==NULL) {
        *PFin=PTrav;
    } else {
        PTrav->Suivant->Precedent=PTrav;
        PTrav->Precedent=NULL;
    }
    return PTrav;
}
 
ListeDEntiers *AjoutBase(int Valeur, ListeDEntiers *ptr) {
    ListeDEntiers *PTrav;
    PTrav=malloc(sizeof(ListeDEntiers));
    if(ptr!=NULL) {
        PTrav->UnEntier=Valeur;
        PTrav->Suivant=ptr;
        PTrav->Suivant->Precedent=PTrav;
        PTrav->Precedent=NULL;
    } else {
        PTrav->Suivant=ptr;
        printf("\nVeuillez d'abord creer une liste\n");
    }
    return PTrav;
}
 
ListeDEntiers *AjoutFin(int Valeur, ListeDEntiers *ptr) {
    ListeDEntiers *PTrav;
    PTrav=malloc(sizeof(ListeDEntiers));
    if(ptr!=NULL) {
        PTrav->UnEntier=Valeur;
        PTrav->Precedent=ptr;
        PTrav->Precedent->Suivant=PTrav;
        PTrav->Suivant=NULL;
    } else {
        PTrav->Precedent=ptr;
        printf("\nVeuillez d'abord creer une liste\n");
    }
    return PTrav;
}
 
void LitPile(ListeDEntiers *ptr) {
    ListeDEntiers *PTrav;
    PTrav=ptr;
    if (PTrav!=NULL) {
        while (PTrav) {
            printf("\n%d", PTrav->UnEntier);
            PTrav=PTrav->Suivant;
        }
    } else {
        printf("\nIl n'ya pas de liste à afficher");
    }
}
 
void LitPileInverse(ListeDEntiers *ptr) {
    ListeDEntiers *PTrav;
    PTrav=ptr;
    if (PTrav!=NULL) {
        while (PTrav) {
        printf("\n%d", PTrav->UnEntier);
        PTrav=PTrav->Precedent;
        }
    } else {
        printf("\nIl n'ya pas de liste à afficher");
    }
 
}
 
void SupressionLiberation(ListeDEntiers *ptr) {
    ListeDEntiers *PTrav;
    ListeDEntiers *PDelete;
    PTrav=ptr;  
    while (PTrav) {
        PDelete=PTrav;
        PTrav=PTrav->Suivant;
        free(PDelete);
    }
    free(PTrav);
    PTrav=NULL;
}

Si vous voyez d'autre chose à modifier, n'hesitez pas à me le dire :)

Merci