Reprise du message précédent :

si tu détaillais un peu les endroits où tu es bloqué ... j'ai mis tout ce que tu avais à corriger dans mon post précédent. le code final ne devrait pas prendre plus d'une trentaine de lignes.
 
et quand je dis de recopier & debugger les exemples qsort() & co, c'est pas pour faire joli, c'est crucial. cf l'exemple dans la msdn : http://msdn.microsoft.com/library/ [...] _qsort.asp  
 
si tu veux comprendre l'algo, http://www.google.com/search?q=quicksort+explained . ce n'est pas indispensable pour son utilisation.

 
Merci  
ben deja ce qui va pas c'est que la taille de mon tableau j'en sais rien elle peut changer a chaque fois... d'ou l'interet d'avoir fait des liste chainee, alors si c pour le remettre dans un tableau ca perd tout son sens , et je sais pas comment faire un tableau dynamique...  
 
j'ai fait des recherche a propos de qsort, mais rien de t res concret..
 
 
je comprends pas grand choses aux arguements qu'il faut lui passer, ni pq... j'approfondirais bien le sujet, mais la ca presse, sinon ca va etre dmc, mon projet ... alors j'avais commencé avec bjone, un  truc puis ca bugue encore mais j'arrive pas a corriger... tu me proposes une autre facon de faire, mais j'arrive pas non plus alors je sais plus que faire ni quoi choisir...
 
je sais que vous etes pas ici pour faire le boulot a ma place, mais la... je capte vraiment plus rien.. et le fait que c urgent ca me stress encore plus
 
v peter un cable moi    
 
merci a+

c'est un tableau temporaire. les données temporaires n'ont rien d'extraordinaire, même dans le cadre d'une liste chaînée. c'est le genre de stratagème qu'on peut utiliser pour sauvegarder la liste dans un fichier : stocker tous les pointeurs, remplacer les pSuivants & co par les indices dans le tableau ... bref.
 
en code, tout est une question de compromis, souvent entre vitesse / espace mémoire / complexité du code. je t'ai donné la solution qui me semble être la plus simple niveau 'complexité du code', si elle te semble plus compliquée que celle de bjone, utilise la sienne.

_Maximus_, poste les deux dernières versions du code des deux possibilités que l'on t'a proposé pour voir ce qui colle pas (histoire qu'on se base pas sur un vieux post)

 
Merci, c'est plus la peine.. j'ai procédé autrement avec le tri a bulle, c'est barbare comme code mais ca marche
 
au lieux d'inverser les pSuivant et pPrecedant j'inverse carrément toute les données parce que apparement c cette inversion ki foirait le tout :
 
voila mon code a present :  
 

 
 
m'enfin j'ai tjrs pas compris pq ca marchait pas simpelemtn en inversant les maillon , l'algo en lui meme etait juste a mon avis...
 
Merci pour ton aide
 
a+

code de porc, ton prof va te déchirer.
 
tout l'intêret des (double) listes chaines c'est de manipuler les pointeurs suivants/précédents. tu est à coté du but de l'exercice (donc => 0). tu peux garder cette solution de coté si tu n'y arrives pas, mais tu auras autant de points que si tu rendais rien (enfin j'éxagére un petit peu).
 
poste le code tu tri par sélection, et du tri par qsort que tu as, qu'on puisse t'aider...

d'autant plus que dans ta routine d'échange, tu passes par une structure temporaire ... non allouée ...
résultat: si ça marche c'est par la voie du saint-esprit.

sinon le code "d'échange" sera le même avec le tri à bulle et sa variante par sélection.  
 
les deux cas particuliers de cet échange seront si un des éléments est/ou se retrouve premier ou dernier.
 
Dans le cas du premier y'a pas d'élément précédent, on ne doit pas essayer de mettre à jour le pointeur suivant de l'élément précédent, et fo modifier le pointeur racine.
 
Dans le cas du dernier y'a pas d'élément suivant, donc on ne doit pas essayer de mettre à jour le pointeur précédent de l'élément suivant.

Tout a fait d'accord, mais j'y suis pas arriver, et la mon cerveau il sature, c tout ce que j'ai trouvé pour m'en sortir  
 
sinon voila le dernier code que j'avais :  
 

 
mais ca trie pas correctement et il manque des maillions...  
j'ai tout essayer au moment d'inverser les pointeur, mais rien a faire...  
 
merci

bon comme j'ai déjà dit:
 
remplaçe if(strcmp(pMem->nom, pI->nom)!=0)  
par if( pMem != pI )

 
base toi sur ça.

ensuite comme tu peux avoir à modifier le premier, il faut que ton appel de routine ressemble à ça:
 
void TriNom(struct DATA **Premier)
 
///////////////////////////
 
ou à ça:
struct DATA *TriNom(struct DATA *Premier)
 
avec un appelle du style:
 
main()
{
 struct DATA *PremierElement;
 
..... Y'a plein d'éléments ajoutés dans la double liste chainés
.....
 
 
 PremierElement=TriNom(PremierElement);
}
 
porké ? passke un élément peux prendre la plaçe du premier élement, et donc le pointeur "racine" peut avoir à être modifié.
 
donc soit le pointeur "racine" tu le passes lui-même par pointeur (ou par référence si tu est en C++ ), ou tu le retournes comme ça la fonction appellante pourra mettre à jour le pointeur racine de son coté.

pour l'insertion ça doit ressembler à quelque chose du genre:
 
if( meilleur != courant )
{
   struct DATA *prec;
 
   /////////////////////
   // on "enlève" meilleur  
   meilleur->précédent->suivant = meilleur->suivant;
 
   // meilleur n'est pas le dernier
   if( meilleur->suivant )
      meilleur->suivant->précédent = meilleur->précédent;
 
   ////////
   prec=courant->précédent;
 
   if( prec )
     prec->suivant = meilleur;
   else
     racine = meilleur;
 
   meilleur->précédent = prec;
   courant->précédent = meilleur;
 
   meilleur->suivant=courant;  
}
 
en principe ça devrait ressembler à cela....

jviens juste de faire ce TP cette semaine a mon école...cai trop easy !
...si tu ve jte le fé, et avec plein de commentaire ds le code !
Jregarde ca ce soir et jte mail le tout demain aprem ! (source C)

...et je vois deja ds ton enonce une maladresse :
NE JAMAIS déclaré les dimensions du tableau en dur ! tjs en #define ! (du - surtout pour ce type de structure ...)

 
J'ai fait comme tu as dit, mais ca fait une boucle infinie maintenant :
 

 
C'est super sympa de proposer, mais c'est trop tard c'est demain qu'on remet le tout... maintnant chui entrain d'essayer de faire comme bjone m'explique juste pour le principe de pas me laisser battre par cette @##{#@ de machine...
 
mais merci quand meme c'est sympa d'avoir proposé,... mais si tu as le temps tu peux tjrs me l'envoyer quand meme ca m'interresse de voir comment tu as fait.  
 
Merci a toi
 

 
presque....
 
je dirais:
 
while(
{
  if( pMem != pI )
  {
    ....
  }
  else
    pI=pI->suivant;
}
 
si tu rentres dans le if, le meilleur étant inséré devant le courant, il faudra encore "retester" le courant par rapport avec ses suivants.
 
si tu ne rentres pas dans le if, le courant est bien à sa place on peut passer au suivant....
 
////
 
tu n'a pas l'air d'avoir compris cette histoire de pointeur "racine" qui pointe sur le premier.
 
le pointeur "deb" tu le retournes, afin que la fonction appellante puisse mettre à jour sur le pointeur racine de son coté...

 
 
Bon oui, j'avais oublié de mettre le pI=pI->pSuivant, logique que ca bouclait , mea culpa...
 
sinon j'ai fait comme t'as dit, et ca donne ce ci :  
 

 
et dans le main.c je fais ptr=TriNom(ptr);
 
ca boucle plus, ca affiche tous les enregistrement, mais pas encore trié...  
 
voila comment sont disposé les nom au depart :
 

 
et il ressortent dan le meme ordre...
 
 

le:
 

 
est de trop.

d'ailleurs je comprends pas comment ça a fait pour pas partir en boucle infinie  

sinon l'écriture peut se simplifier:
 

 
par ça:

 
j'ai pas tester le code, mais le truc qui marche doit en être pas loin....

 
Toujours rien    il trie pas...
fin bon s'pas grave, v garder ma solution pourrie, ca ira avec ca, c'est deja grace a toi que j'ai pu la trouver..
 
Bon! Merci bcp pour ton aide...
 
faudra que je m'y mette serieusement aux methodes de tri en C, pasque cai pas la joie la
 
 
Merci a+

fait voir ton code qui saisit/affiche.

cé pas possib, il doit se passer quelque chose, soit y devrait y avoir une boucle infine, soit le liste devrait être explosée...

 
Ca risque d'etre long, c'est un affichage avec une interface graphique etc...
 
 
sinon en gros  ca se passe comme ca  
 
 
//saisie d'un mot clef au clavier
 
//Recherche dans un fichier
 
//Mise en memoire dans une liste chainée des enregistrements qui correspondent au mot clef, ma fonction recherche() retourne l'adresse de debut de la liste chainee
 
ptr=TriNom(ptr); //On 'trie'
 
//Et on affiche  
 
mais tout le code fonctionne parfaitement a part les tri,   , tout les pPrecedent, et pSuivant sont ok... j'ai plusieur fois testé l'affichage de la liste chainee en partant du premier maillioon et en suite en partant du dernier et c bon... donc a ce niveau la il n'y a aucun doute.
 
Vala..
 
 

 
Ben il me sort les enregistrement tel qu'ils sont dans le fichier ( dans le meme ordre ) donc y a pas eu de tri...  
s'bizzare..

fait un test du style:
 
Courant = Racine;
 
while( Courant->Suivant )
{
  Affiche( Courant );
  Courant=Courant->Suivant;
}
 
while( Courant )
{
  Affiche( Courant );
  Courant=Courant->Precedent;
}
 
ça devrait permettre de tester le chainage...

mon cerveau doit avoir du mal à simuler du C en ce moment  

Putain chui q'un pov con...  
 
j'avais oublié qu'il fallait que je click sur trier par nom et que ca ne se faisais plus directement dans mon main pffffffffffffffffffffffffffffffffffffff
 
bon ben sinon ca marche, sauf que le premier enregistrement est vide    
 
sinon le reste est bien trié

Il m'affiche ceci :
 

 
et le 'mnoz'
ne s'affiche pas..
 
sinon c bien trié apparament, plus ke ce petit bug a resoudre

c bon jai trouvé fallait mettre  
 
Courant->pSuivant dans le while et non Courant
 
Bon ben voila ca marche... big merci...
 

 
 

arf

 
hum.. ben oué desolé quoi ca arrive d'etre fatigué :'( et de faire n'importe quoi...
 
merci encore
a+

salut bjone, c'est juste pour dire, que j'ai eu 85% a mon projet... donc c'est super.  
 
C'est en partie grace a ton aide, merci encore
 
a+

Désolai pour le retard mais j'a v difficilement accès au net !
Je te mail tous ca sans tarder cad :
Implémentation par rapport a ta liste doublement chainée des fonctions:
- Affichage de la liste
- Retirer un maillon de la liste
- Ajouter un maillon a la liste (= enregistrement)
- Trier la liste par nom
...bref les fonctions essentielles de traitement de liste chainée
 
PS: pour la fonction trier, je suis passez par un tableau de pointeur de taille dynamique (sizeof(nb_maillon))
Chaque case du tableau contient un pointeur sur un maillon. (tab[0] pointe sur le 1er maillon et Tab[N] le dernier)
Ensuite j'ai trié mon tab de pointeur et reaffecter les pointeur prec et suiv de chaque maillon a partir de ce tab de pointeur trié (ce qui me semble le plus logique, le plus simple/pratique surtout)

 
salut,
 
merci c sympa
c'est avec plaisir que je matterai toute tes fonction
 
a+  

après avoir trouvé ça:
 typedef enum boolean{
 TRUE,
 FALSE=!TRUE
 };
 ...
 fonction (...)
 {
  ...
  void *p=NULL;
  ...
  switch((!p))
  {
  case TRUE:
   ...
   break;
  case FALSE;
   ...
   break;
  }
 ...
 }
J'ai revu le code du tri d'une liste chainé. Je regrette que le code soit devenu moins lisible.  
 /*fonction de teste pour le tri d'une liste*/
 int
 sort_test
         (void *p,int flag)
 {
         switch (flag)
         {
         case 0:
                 if (((h_contents *)p)->next && ((h_contents *)p)->pos.pos>((h_contents *)p)->next->pos.pos)
                         return 0;
                 break;
         default:
                 if (((h_contents *)p)->prev && ((h_contents *)p)->pos.pos<((h_contents *)p)->prev->pos.pos)
                         return 0;
                 break;
         }
         return 1;
 }
 /fonction pour le tri d'une liste*/
 void
 sort_contents
         (
                 void **h,
                 int (*test)(void *,int),
                 void *(*read_next)(void *),
                 void (*set_next)(void **,void *),
                 void *(*read_prev)(void *),
                 void (*set_prev)(void **,void *)
 )
 {
         /*DECLARATION*/
         void *ph,*after,*p,*pa,*pb;
         void **aptr[5]={&ph,&pa,&pb,&p,&h[0]},
                 **bptr[5]={&ph,&pb,&pa,&p,&h[0]};
         void ***plist[2]={aptr,bptr};
         void **ptrs[2][5]={     {&pa,&ph,&pb,&p,&h[0]},
                                 {&pa,&p,&pb,&ph,&h[0]}};
         void *(*___read___[2])(void *)={read_prev,read_next};
         void (*set[2])(void **,void *)={set_next,set_prev};
         unsigned short int i,j,tv[2]={3,0};
         int pset;
         /*CODE*/
         ph=h[0];
         while (ph)
         {
                 after=(*read_next)(ph);
                 pset=(*test)(ph,0);
                 while (!(*test)(ph,pset))
                 {
                         for (i=0;i<4;i++)
                                 if (i<2)
                                         plist[pset][1][0]
                                         =(*___read___[1-pset])(plist[pset][i][0]);
                                 else
                                         plist[pset][i][0]
                                         =(*___read___[(i-2)^pset])(plist[pset][0][0]);
                         for (j=0;j<4;j++)
                                 (*set[!(j<2)^pset])(plist[pset][tv[j%2]],plist[pset][j][0]);
                         if (ptrs[pset][0][0])
                                 (*set_prev)(ptrs[pset][0],ptrs[pset][1][0]);
                         if (ptrs[pset][2][0])
                                 (*set_next)(ptrs[pset][2],ptrs[pset][3][0]);
                         else
                                 ptrs[pset][4][0]=ptrs[pset][3][0];
                 }
                 ph=after;
         }
 }