programmatin des piles et listes en C

Bonjour;
SVP s'il ya qque qui peut me programmer cet algo en langage C
car je ne sais pas comment on programme les listes et les piles?!

/////
Tour de boucle 2 :
Pile1=1,5, Pile2=vide, Liste=4
Je colorie 1
Je regarde les voisins de 1 (2,4) 2 et 4 sont de la bonne couleur mais 4 a déjà été traité
Pile1=5, Pile2=2, Liste=4,1
Je colorie 5
Je regarde les voisins de 5 (2,4,6,8) 2 et 4 sont de la bonne couleur mais ont déjà été traités
Pile1=vide, Pile2=2, Liste=4,1,5
J'inverse les piles
/////

Merci bien d'avance

Salut,

Tu devrais apprendre à faire des piles et des listes.

> SVP s'il ya qque qui peut me programmer cet algo en langage C
Hahahaha.
Relis donc le règlement : http://www.cppfrance.com/reglement.aspx

oui vous avez raison
Merci de me le dire,,c'est pourquoi j'ai essayé de le faire personnelement mais je trouve qque pbs dans l'exécution:==>le terminal m'affiche processus arrêtè après que je lui donne la case de départ et la case d'arivèe ( je parle d'un labyrinthe)

Voici mon pg de test de recherche :
//Recherche chemin
PileEntiers *pile1;
PileEntiers *pile2;
int tab[40];
int succ_h,succ_d,succ_b,succ_g;
int don,don_pas,i=0,j=0;

    pile1 = NULL;
    pile2 = NULL;
   
    pile1 = empiler (cas_d, pile1);
    while(pile1!=NULL)
    {
        don=consulter(pile1);
        tab[i]=don;
        i++;
        printf("la case marquèe est :  %d ",tab[i]);
        pile1=depiler(pile1);
        //test des successeurs et remplissage de la pile2
        if (verifier_haut(A,don)==0) {succ_h=don-8;if (succ_h!=cas_a) pile2 = empiler (succ_h, pile2); else break;}
        if (verifier_droite(A,don)==0) {succ_d=don+1;if (succ_d!=cas_a) pile2 = empiler (succ_d, pile2); else break;}    
        if (verifier_bas(A,don)==0) {succ_b=don+8;if (succ_b!=cas_a) pile2 = empiler (succ_b, pile2); else break;}
        if (verifier_gauche(A,don)==0) {succ_g=don+8;if (succ_g!=cas_a) pile2 = empiler (succ_g,pile2); else break;}
        //la pile1 prend les elements de la pile2
        while (pile2!=NULL)
        {
        don_pas=consulter(pile2);
        while(j<i) //verifier que la donnèe de passage n'existe pas dans le tab de marquage
        { if (tab[j]!=don_pas) j++ ; else { depiler(pile2);  break;}}
        if (j==i) pile1=empiler(don_pas,pile1);
        j=0;
        }    
    }
    if (succ_h==cas_a) tab[i]=succ_h;
    if (succ_d==cas_a) tab[i]=succ_d;
    if (succ_b==cas_a) tab[i]=succ_b;
    if (succ_g==cas_a) tab[i]=succ_g;
   
    if (pile1==NULL) printf("\npas de chemin");
    //desallocation
    desallouer (pile1);
      pile1 = NULL;
    desallouer (pile2);
      pile2 = NULL;



jespère bien que qqun me l'explique pourquoi??!
Merci
Crdlt

Salut,

deja dans ton programme il y a des affaires qui nous manquent: comme les definitions des fonctions empiler, depiler,consulter,verifier_haut .. et j'en passe! ou encore certaines variables qui apparaissent comme par miracle : cas_d  .  Il serait interessant que tu postes le code comme il faut ou du moins un lien vers celui-ci sinon nous resterons tous dans le brouillard concernant ton probleme.

Bonne continuation.
[ Lien ]
je suis heureux de faire partie d'une grande famille ...!

voici mon code complet!!!SVP si qqun peut m'aider à trouver mes fautes!!
MERCI BIEN!!

#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
#include "graphiqu_enis.h"

//Manipulation des piles
typedef struct pileentiers {
  int donnee;
  struct pileentiers *suivant;
} PileEntiers;

PileEntiers *empiler (int a, PileEntiers* p) {
  PileEntiers *nouveau;

  nouveau = (PileEntiers *) malloc (sizeof (PileEntiers));
  if (nouveau == NULL) {
    printf ("Erreur d'allocation\n");
    exit (1);
  }

  nouveau->donnee = a;
  nouveau->suivant = p;
  return nouveau;
}

PileEntiers *depiler (PileEntiers *p) {
  PileEntiers *sommet;

  sommet = p;

  if (sommet != NULL) {
    sommet = sommet->suivant;
    free (p);
  }

  return sommet;
}

int consulter (PileEntiers *p) {
  if (p == NULL) {
    printf ("Erreur : pile vide");
    exit (1);
  }

  return p->donnee;
}

void desallouer (PileEntiers *p) {
  PileEntiers *sommet = p;

  while (sommet != NULL) {
    sommet = depiler (sommet);
  }
}
void afficher_contenu (PileEntiers *p) {
  PileEntiers *pile = p;
 
  printf ("Contenu de la pile :\n");
  while (pile != NULL) {
    printf ("\t%d\n", pile->donnee);
    pile = pile->suivant;
  }
  if(pile==NULL) printf("pile vide\n");
}

//fonction qui verifie si une case donnee admet un mur a droite ou non; cette fonction retourne 1 si oui, 0 sinon
int verifier_droite(int X[][50],int cas)
{
int d;
if((cas>=1)&&(cas<8)) d=X[0][cas-1];
else if ((cas>=9)&&(cas<8*2)) d=X[2][cas-9];
else if ((cas>=17)&&(cas<8*3)) d=X[4][cas-17];
else if ((cas>=25)&&(cas<8*4)) d=X[6][cas-25];
else d=1;
return d;
}

//verifier bas
int verifier_bas(int X[][50],int cas)
{
int b;
if((cas>=1)&&(cas<=8)) b=X[1][cas-1];
else if ((cas>=9)&&(cas<=8*2)) b=X[3][cas-9];
else if ((cas>=17)&&(cas<=8*3)) b=X[5][cas-17];
else if ((cas>=25)&&(cas<=8*4)) b=1;
return b;
}

//verifier gauche
int verifier_gauche(int X[][50],int cas)
{
int g;
if((cas>1)&&(cas<=8)) g=X[0][cas-2];
else if ((cas>9)&&(cas<=8*2)) g=X[2][cas-10];
else if ((cas>17)&&(cas<=8*3)) g=X[4][cas-18];
else if ((cas>25)&&(cas<=8*4)) g=X[6][cas-26];
else g=1;
return g;
}
//verifier haut
int verifier_haut(int X[][50],int cas)
{
int h;
if((cas>=1)&&(cas<=8)) h=1;
else if ((cas>=9)&&(cas<=8*2)) h=X[1][cas-9];
else if ((cas>=17)&&(cas<=8*3)) h=X[3][cas-17];
else if ((cas>=25)&&(cas<=8*4)) h=X[5][cas-25];
return h;
}

int main(void) {
int A[50][50];
int abs=92.5;
int hv=400;
int bv=305;
int lh=305;
int d=20;
int k=1;
int cas_d,cas_a;
char a[3];

/* Initialisation de l'environnement grahique avec les coordonnées
     extrêmales. */
Initialisation_Graphique(0,0,650,450);

/*Trassage de rectange*/
DrawRectangle(20,20,600,400,Red);


    FILE* fichier = NULL;


    fichier = fopen("fich.txt", "r");
    if (fichier != NULL) {
        int c;
        int i,j;
        i=j=0;
        //Lecture de fichier ligne par ligne
        while((c=fgetc(fichier)) != EOF) {
            if(c=='\n') {
                i++;
                j=0;
            }
            else if(c=='0' || c=='1')
                A[i][j++]=c-'0';
        }
    
       //Traçage des murs
    for(i=0;i<8;i++)
        {
             
         
    if (i%2==0) //Les murs verticaux
    {
         
        for(j=0;j<8;j++)
            {
                Hauteur_Texte(10.0);
                itos(k,a);
                EcritXY(46.25+72.5*j,352.5-95*i,a,Black);
                k++;
              if (A[i][j]==1)
                Trait(abs,bv,abs,hv, Red);
              abs+=72.5;
            }
        abs=92.5;
        hv=bv;
        bv-=95;
                    
    }
    else //Les murs horizontaux
    {
        for(j=0;j<8;j++)
            {
                Hauteur_Texte(10.0);
                itos(k,a);
                EcritXY(46.25+72.5*j,352.5-95*i,a,Black);
                k++;
            if (A[i][j]==1)
                Trait(d,lh,abs,lh, Red);
            d+=72.5;
            abs+=72.5;
            }
        abs=92.5;
        d=20;
        lh-=95;           
    }
    }
}
//Choisir les cases

do{
printf("\ndonner la case de depart : \t");
scanf("%d",&cas_d);
printf("\ndonner la case d'arrivèe : \t");
scanf("%d",&cas_a);
}
while(cas_d<1 || cas_d>32 || cas_a<1 || cas_a>32);


//Recherche chemin
PileEntiers *pile1;
PileEntiers *pile2;
int tab[40];
int succ_h,succ_d,succ_b,succ_g;
int don,don_pas,i=0,j=0;

    pile1 = NULL;
    pile2 = NULL;
    
    pile1 = empiler (cas_d, pile1);
    afficher_contenu(pile1);
    
    while(pile1 !=NULL)
    {    
        don = consulter (pile1);
        printf("\nla donnee consultee est %d",don);
        tab[i]=don;
        printf("\nla donnee mis dans le tableau est %d\n",don);
        i++;printf("%d",i);
        pile1=depiler(pile1);
        
        
        //test des successeurs et remplissage de la pile2
        
        if (verifier_haut(A,don)==0) {succ_h=don-8;printf("trouve succ_h=%d",succ_h);if (succ_h!=cas_a) pile2 = empiler (succ_h, pile2); else                                                                             break;}
        if (verifier_droite(A,don)==0) {succ_d=don+1;printf("trouve succ_d=%d",succ_d);if (succ_d!=cas_a) pile2 = empiler (succ_d, pile2); else                                                                         break;}    
        if (verifier_bas(A,don)==0) {succ_b=don+8;printf("trouve succ_b=%d",succ_b);if (succ_b!=cas_a) pile2 = empiler (succ_b, pile2); else                                                                             break;}
        if (verifier_gauche(A,don)==0) {succ_g=don+8;printf("trouve succ_g=%d",succ_g);if (succ_g!=cas_a) pile2 = empiler (succ_g,pile2); else                                                                             break;}
        //la pile1 prend les elements de la pile2
        while (pile2!=NULL)
        {
        don_pas=consulter(pile2);
        while(j<i) //verifier que la donnèe de passage n'existe pas dans le tab de marquage
        { if (tab[j]!=don_pas) j++ ; else { depiler(pile2);  break;}}
        if (j==i) pile1=empiler(don_pas,pile1);
        j=0;
        }    
    }
    
    if (succ_h==cas_a) tab[i]=succ_h;
    if (succ_d==cas_a) tab[i]=succ_d;
    if (succ_b==cas_a) tab[i]=succ_b;
    if (succ_g==cas_a) tab[i]=succ_g;
    
    if (pile1==NULL) printf("\npas de chemin\n");
    //desallocation
    desallouer (pile1);
      pile1 = NULL;
    desallouer (pile2);
      pile2 = NULL;




            Attente ();
        Fin_Graphique ();

        fclose(fichier),fichier=NULL;

    return 0;
}