Discussion :

[BnY]

j'ai une tite fonction qui se sert de piles pour calculer des distances dans une boucle for...:

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
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
 
fonction_for(int IDa,int j,int DF,int *tabID,int tab[MAX_AEROPORTS+1][MAX_AEROPORTS+1],pile **e, pile **d) 
{        
    int k,K,y,z,dt=0;
 
   for(k=1;k<=MAX_AEROPORTS;k++)
   {
 
       K=POtoID(k,tabID);
 
       z=passe(K,*e);  //si on est deja passé par l'id: retourne 1
 
       if(z==1)
       {
           continue;
       } else {
 
            y=tab[j][k];
 
            if (y==0)
            {
                continue;
            } else {
 
                  if(y<=DF)
                  {
 
                      dt=(((*d)->valeur)+y);
                      printf("a. val. plus new:%d-->%d",y,dt);
                      ajouter(d,dt);
                      ajouter(e,K);
                      if(K==IDa)
                      {
                          printf("Nb d'elements esctp : %d\n",parcourir(*e));
                          printf("Nb d'elements dtot : %d\n",parcourir(*d));
      // ICI C'EST UN "POINT DE FIN": JE VEUX FAIRE UN TEST POUR SAVOIR SI LE DERNIER ELEMENT
      DE LA PILE EST PLUS PETIT QUE LE DERNIER ELEMENT DE L'ANCIENNE PILE. 
SI OUI ALORS ON GARDE CETTE PILE LA.SI NON ON GARDE L'ANCIENNE.
      C'EST FAISABLE ??
 
                         retirer(e);
                         retirer(d);
                         retirer(e);
                         retirer(d);
                         break;
                     } else { 
                           int a;
                           a=parcourir(*e);
                           if(a<=10)
                           {
                                 fonction_for(IDa,k,DF,tabID,tab,e,d);  // modifs sur arguments
                           } else {
                                  retirer(e);
                                  retirer(e);      
                                  break;
                           }
                    }
                  } else {
                   //printf("\ny NUL:%d, et k:%d",y,k);
                   continue;
                 }
            }
       }
    }
}
 
 
 
trajet(...)
{
 ...
 D=IDtoPO(IDd,tabID,MAX_AEROPORTS);
 A=IDtoPO(IDa,tabID,MAX_AEROPORTS);
 DA=tab[D][A];
 
 if(DA<=DF)
 {
  printf("trajet direct");  // ajouter modifs en consequence
 
 } else {
 
  for(j=1;j<=MAX_AEROPORTS;j++)
  {
   clear(&esctemp);
   clear(&dtot);
 
   ajouter(&esctemp,IDd);
   i=IDtoPO(IDd,tabID,MAX_AEROPORTS);
   x=tab[i][j];
   if(x==0)
   {
    continue;
   } else {
    if(x<=DF)
    {    
     ajouter(&dtot,x);
 
     printf("\nDEB: ancienne valeur plus new:%d-->%d",x,dtot->valeur);
     J=POtoID(j,tabID);
     ajouter(&esctemp, J);
     fonction_for(IDa,j,DF,tabID,tab,&esctemp,&dtot);  // modifier dtot et esctemp
    } else {
     continue;
    }
   }
  }
 }
 
...
}

la question est en commentaires en maj...

[BnY]

PS je n'ai pas mis certaines declarations mais ne vous inquietez pas pour ca la boucle marche super, y a pas de problemes ... c'est juste cette histoire de comparaison et de recuperer la pile (entiere) precedente§...

[Swoög]

ok

Il faudrait expliciter ce que tu entends par dernier élément de la pile (tu as deux piles) l'ancien, l'ancienne pile, cette pile là

[BnY]

oki alors en fait ma boucle for me permet d'ajouter des valeurs dans une pile...

ensuite quand on arrive a un point de fin ( IDfinal trouvé ) : on a donc une pile pleine de valeurs... ( par exemple la pile dtot: enregistre les valeurs des distances, donc la derniere valeur enregistrée est la dist totale de ce parcours...

et a mon point de fin: je veux comparer cet element avec le dernier element de la pile d'avant, correspondant au parcours d'avant, et selon qui est le plus petit, garder en memoire les piles entieres dtot et esctemp correspondant plus petit...

je m'explique bien ??

[Swoög]

oui, je suppose que ces deux paires de piles sont dipo en mémoire, et accessible au niveau de ton point de fin ?

[BnY]

ben justement c'est ca le truc je suis pas sur que l'ancienne soit toujours accessible vu kon la "nettoie" et l ecrase...

je pensais ptet faire une aut pile du genre:

Code :

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

1
2
3
4
5
6
7
8
9
 
typedef struct pile
{      
 
pile * esc=NULL;
pile *dist=NULL;
struct pile *prec;
 
} pilefin ;

avec les piles esc et dist:

Code :

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

1
2
3
4
5
typedef struct pile
{
        int valeur;
        struct pile *prec;
} pile ;

je sais pas si je me complique pour rien ou pas en fait... et le truc c'est que j'imagine que c'est plus dur a manipuler cette nouvelle pile, nan ??

[Swoög]

Bah... disons que dans ce cas, tu as une pile de piles... c'est pas forcément plus difficile à manipuler... pas pour la façon dont tu veux l'employer en tous cas