pile dynamique

Question

Bonjour! Voila j'ai un problème. Je voudrais mélanger ma pile dynamique de façon aléatoire. Peut on directement mélanger la pile ou alors passer la pile dans un tableau. Voici mon code : 


   int main(int argc, char *argv[])
{
    int tab = 100;

    pile_t * p;
    int x,i;
    p=init(10);

   for (i=0;i<=20;i++)
    {
        empile(p,i);      // permet d'empiler mes 21 chiffres
        printf("%d",i);
    }

   printf("
");

   for (i=0;i<=20;i++)
    {
        tab[i]=depile(p,&x);   // stock dans un tableau
        printf("%d",tab[i]);
    }
   return 0;
}

Je ne sais pas si la méthode est la bonne , je vais me servir de cette pile pour un jeu de carte.  Quand je stock dans mon tableau j'affiche que des 1 lors de la depile
(  tab[i]=depile(p,&x)  ).

Merci pour votre aide.

deadhand · Answer

Re ! 
Il faudrait que tu montres ton code pour tes fonctions 'init', 'empile' , 'depile' pour résoudre ton problème !

Ensuite : tu peux initialiser ta piles avec deux autres : Tu dépile ta première pile et tu empile ce qui a été dépilé sur l'une ou l'autre de tes deux piles. Et ce jusqu'a ce qu'il en reste plus rien de ta première pile. Ensutie tu la recomposes en concatenant tes deux piles. Tu peux recommencer l'opération plusieurs fois pour bien mélanger. (Ca fait beaucoup de mot 'pile' :) )

korin221 · Answer

Voila mon code 

pile_t * init(int pas)
{
  pile_t * adr_pile = NULL;

  adr_pile = (pile_t *)malloc(sizeof(pile_t));

  if ( adr_pile )
  {
    adr_pile->n = -1;
    adr_pile->pas = pas;
    adr_pile->tete = 0;
    adr_pile->sect = 0;
  }

  return adr_pile;
}

void empile(pile_t * p, variant x)
{
  if ( vide(p) )
  {
    p->tete = (section_t *)malloc(sizeof(section_t));
    p->sect = p->tete;
    p->sect->tab = (variant *)malloc((p->pas) * sizeof(variant));
    p->sect->suiv = 0;
    p->sect->prec = 0;
  }
  else
  {
    if (!((p->n + 1) % (p->pas)))
    {
      p->sect->suiv = (section_t *)malloc(sizeof(section_t));
      p->sect->suiv->prec = p->sect;
      p->sect = p->sect->suiv;
      p->sect->tab = (variant *)malloc((p->pas) * sizeof(variant));
      p->sect->suiv = 0;
    }
  }
  p->n = p->n + 1;
  *(p->sect->tab + (p->n) % (p->pas)) = x;
}


unsigned short int depile(pile_t * p, variant * x)
{
  unsigned short int succes = 0;

  if ( !vide(p) )
    {
      *x = *(p->sect->tab + (p->n) % (p->pas));
      p->n = p->n - 1;
      if (!((p->n + 1) % (p->pas)))
      {
        if ( p->sect->prec != 0 )
        {
          p->sect = p->sect->prec;
          free(p->sect->suiv);
          p->sect->suiv = 0;
        }
        else
        {
          free(p->tete);
          p->sect = 0;
        }
      }
      succes = 1;
    }
  return succes;
}



Me je voulais savoir si on pouvais justement stocker la pile dans un tableau et apres mélanger le tableau et ensuite remettre le tableau dans la pile pasque la je voi pas comment faire pour utiliser plusieurs pile et les mélanger! J'ai fait tous mon code de jeux + le sdl mais la j'ai du mal avac la pile.. Merci!

deadhand · Answer

Tu veux dire quoi par "p->sect" ?

korin221 · Answer

En faite c'est pour faire une section ou un maillon. Par exemple dans ce cas
p->sect->suiv = 0;  sa veut dire qu'il n'y a pas de section qui va suivre et p c'est l'adresse de la pile

Pile dynamique

4 réponses

Votre réponse

Discussions similaires