Discussion :

[line86]

Bonsoir a tous, voila j'aimerais connaitre la description en francais de cette structures.
Pour moi, cette une liste chainée qui point sur une pile...
Mais comme je ne suis pas sur du tout, je vous demande votre avis
merci d'avance

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
typedef struct cel
{
  Point valeur;
  int passage;
  struct cel *next;
  struct cel *prev;
} Cellule;
 
typedef struct
{
 Cellule *queue;
 Cellule *tete;
}Pile;

[Médinoc]

Pour moi, la structure Pile sert à encapsuler la liste chaînée. C'est typiquement le genre de structure qui pourrait contenir un membre "Taille".

Je dois avouer que, utilisée aussi nue avec une liste déjà doublement chaînée, je n'en vois pas trop l'intéret...

[souviron34]

Pour moi, la structure Pile sert à encapsuler la liste chaînée. C'est typiquement le genre de structure qui pourrait contenir un membre "Taille".

Je dois avouer que, utilisée aussi nue avec une liste déjà doublement chaînée, je n'en vois pas trop l'intéret...

si si...

ça peut servir à éviter (ça revient au même, mais ça peut être plus "propre") de définir en global dans un fichier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Cellule *Tete, *Queue ;

pour permettre par exemple d'explorer d'un côté ou de l'autre sans traverser..
(Un exemple que j'avais utilisé : la liste était ordonnée par temps. Temps d'un nouvel élément plus proche de temps(tete) que de temps(queue), alors explorer par tete, sinon explorer par queue).

Et donc, pourquoi pas définir un nouveau type, et mettre en global :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Pile  MaPile ;

certains peuvent trouver ça plus "esthétique"..

[koala01]

Salut,

La structure cel, et le type cellule qui est défini grace à elle est celle d'un élément de liste doublement chainée.

La struture anonyme et le type (sémantiquement mal nommé) pile est une structure qui permet de considérer tous les éléments de la liste comme un tout.

On pourrait tres bien rajouter des informations intéressantes sur la liste considérée comme un tout telles que: sa taille, un pointeur sur l'élément actuellement sélectionné, l'indice (la position) de l'élément actuellement sélectionné etc.

Les avantages sont multiples:

-En passant un seul argument de type pile (j'aurais vraiment préféré qu'il soit liste ) tu passe le début et la fin sur la file, alors que, pour le faire avec les type cellule, tu aurais eu deux arguments à passer

-Si tu a besoin de plusieurs listes dans ton programme, tu peux tres bien te contenter d'un code ressemblant à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
pile MesTroisPiles[3];

qui te permet de gérer séparément les trois listes, alors que sans l'existance du type pile, il t'aurait fallu trouver un nom pour chacun des pointeurs sur le début et sur la fin pour les trois liste que tu aurais voulu gérer...

-fournir un "niveau d'abstraction" supplémentaire: Pour chaque fonction qui doit intervenir sur le type pile, tu passe une variable de type (pointeur sur) pile en parametre, sans avoir à te soucier de la manière dont elle est réellement implémentée:

Le fait d'avoir des fonctions du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void LireFile(pile* toread, FILE* fichier);
void EcrireFile(pile* towrite, FILE* fichier);
void LibererFile(pile* tofree);
...

t'autorise, en tant qu'utilisateur de la liste, à estimer que ces fonctions feront ce qu'elles sont sensées faire, sans avoir à te soucier du "comment" elles le font

[line86]

Merci a vous tous pour vos reponses !!!
C'est plus clair maintenant

ps : je vais renommer ma structure en liste (car effectivement "pile" n'a pas trop ca place ici)

j'ai une autre petite question
Peut on regrouper les deux fonctions qui suivent en une?
Car si j'ai bien compris la structure Liste permet d'encapsuler la structure Cel, donc on pourait les allouer en une seule fois... Mais je pense que des fois je n'aurais besoin que d'une seule structure a la fois, donc pas la peine de les allouer toutes les deux...
lol je ne sais pas trop si j'ai été bien clair

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
Liste* AlloueListe (void)
{
 Liste* p = (Liste*) malloc (sizeof (Liste));
 
 if (NULL != p)
  {
   p->tete = NULL;
   p->queue = NULL;
  }
 return p;
}
 
Cellule* AlloueCellule (Point val)
{
 Cellule* p = (Cellule*) malloc (sizeof (Cellule));
 
 if (NULL != p)
   {
    p->valeur = val;
    p->passage = 0;
    p->next = NULL;
    p->next = NULL;
   }
 
 return p;
}

[gl]

j'ai une autre petite question
Peut on regrouper les deux fonctions qui suivent en une?
Car si j'ai bien compris la structure Liste permet d'encapsuler la structure Cel, donc on pourait les allouer en une seule fois... Mais je pense que des fois je n'aurais besoin que d'une seule structure a la fois, donc pas la peine de les allouer toutes les deux...
lol je ne sais pas trop si j'ai été bien clair

Dans les fait, l'allocation de la LISTE n'a lieu qu'un seule fois (lors de la creation de la liste) alors que l'allocation d'une CELLULE est necessaire a chaque insertion d'element dans la liste. Je ne vois donc pas pourquoi on pourrait chercher a regrouper ces deux fonctions.

[koala01]

Je rejoins l'avis de gl...

En fait, si tu veux travailler en ne passant que pile/liste, la fonction "AllouerCellule" serait, plutot, du genre de "AjouterElement(liste*, point val, int passage)" et se coderait sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
/* fonction inésrant un élément dans la file
 * @in: pointeur sur la liste dans laquelle ajouter l'élément
 *      point composant l'élément
 *      valeur de l'élément
 */
void AjouterElement(liste* laliste, point val, int passage)
{
    /* si le pointeur sur la liste est invalide, 
       ca indique une erreur de programmation */
    assert(laliste!=NULL);
    /* l'allocation de la cellule se fait ici */
    Cellule nouveau=malloc(sizeof(Cellule))
    if(nouveau!=NULL)
    {
        nouveau->valeur=val;
        nouveau->passage=passage;
        nouveau->next=NULL; 
        /* insertion de l'élélment dans la liste */
        /* la liste est peut etre vide 
           Si c'est le cas, nouveau prend la place du début*/
        if(laliste->tete==NULL)
        {
            laliste->tete=nouveau;
            /* le pointeur sur prev de nouveau est donc NULL */
            nouveau->prev=NULL;
        }
        /* Sinon, le nouvel élément se raccroche au dernier de la liste */
        else
        {
            laliste->queue->next=nouveau;
            nouveau->prev=laliste->queue;
        }
        /* Quoi qu'il en soit, le nouvel élément devient le dernier de la
           liste */
        laliste->queue=nouveau;
    }
}