Bonjour. Alors voila j'ai bientot un DS [lundi] et j'ai jusque la tout tenté pour me familiariser avec les listes chainées mais il me reste un gros morceau.
J'ai compris comment les déclarer, comment les remplir (à peu pres). Je sais réaliser une fonction d'ajout en tete et d'ajout en queue.
Cependant je ne sais pas coder la fonction d'ajout a la bonne place ainsi que répondre au deux derniers exos. Je ne suis pas quelqun qui cherche a avoir les réponses et puis basta mais avoir des réponses me permettrait de comprendre beaucoup mieux les mécanismes.
Pour le dernier exercice j'ai quelques notions comme la méthode par bloc qui permet un gain en rapidité mais qui stocke des infos inutilement mais ca en reste la .
Si jamais vous pouviez m'éclaircir sur différents points qui me permmetrait d'avancer a mon ryhtme, voici le DS.
 

 
Merci d'avance

je continue a chercher et je pense avoir bon pour la question 2 de l'exercice 2:
 
// Sous-structure
typedef struct date
{
int jour;
int mois;
int année;
}t_date;
 
//infos utiles
typedef struct infos
{
char titre [50];
char auteur[25];
t_date date;
char style [20];
}t_infos;
 
//infos chainage
typedef struct chainage
{
t_infos infos;
struct chainage * suiv;
}t_chainage;
 
ainsi cela donnerait pour les questions de l'exo 3:
 
FILE *fp;
 
t_infos * pt;
pt=ancre;
 
fwrite(&(pt->infos),sizeof(t_infos),1,fp);
 
fread(&(pt->infos),sizeof(t_infos),1,fp);

ON FAIT PAS LES DEVOIRS

oula mais je ne demande pas du tout ca, juste un peu d'aide car je bloque sur plusieurs points.
 
Par exemple comment faire l'ajout a la bonne place. Je sais deja faire l'ajout en tete et en queue:
 
t_cell * ajout_tete (t_cell* ancre, t_cell * nouvo)
{
/*Valable dans tout les cas*/
nouvo->suiv=ancre ;
ancre=nouvo ;
return ancre ;
}
 
Ajout en queue:
 
t_cell * ajout_queue (t_cell* ancre, t_cell * nouvo)
{
/*Liste Vide*/
if(ancre==NULL) ancre=nouvo ;
/*Si Liste non Vide*/
else {
pt=ancre ;
while(pt->suiv!=NULL)
{
pt=pt->suiv;
}
pt->suiv=nouvo ;
}
return ancre  
 
voila

Pour l'ajout à la bonne place, tu dois travailler avec le noeud suivant du noeud courant.

Pour l'ajout à la bonne place, c'est exactement comme l'ajout en fin de liste à deux détails près : 1) à chaque itération tu te souviens de l'élément précédent et 2) dès que la valeur de l'élement courant dépasse celle de l'élément à insérer, tu t'arrêtes et tu insères après l'élément précédent l'élément courant.

ca y est j'ai réussi a faire tout ce qui était demandé ou quasiment
 
Il me manque plus que la fonction supprimer  

c'est comme la fonction d'ajout, mais ça fait l'inverse. spa trop dur. tu garde un pointeur sur l'élément précédent celui à supprimer, tu fais pointer le suivant de cet élément vers le noeud suivant celui à supprimer pis tu libère la mémoire occupée par le noeud à supprimer.
 
c'est niveau 1ère année de DUT Info ou DUT télécom&réseau.
 
la programmation, c'est simple : suffit de savoir faire des dessins  

héhé ca sent l'ece tout ca >< non ?
 
J'ai également un problème avec l'ajout à la bonne place je sais pas comment faire l'insertion en fait.  
T'as trouvé ?

Ajout a la bonne place :
 
t_cell * ajout_bonneplace (t_cell * ancre, t_cell * nouvo)
{
t_cell * tmp ;
if(ancre==NULL) ancre=nouvo ;
else if(ancre->suiv==NULL)
{
if(ancre->val<nouvo->val) ancre->suiv=nouvo;
else ajout_tete(ancre,nouvo) ;
}
else
{
tmp=ancre ;
while ((tmp->suiv->val<nouvo->val)&&(tmp->suiv !=NULL)  
{
tmp=tmp->suiv ;
if(tmp->suiv==NULL) tmp->suiv=nouvo;
else
{
nouvo->suiv=tmp->suiv ;
tmp->suiv=nouvo ;
}

je ne sais pas si tu aurais le droit, mais il y aurait moyen de creer une fonction inserer (qui prend comme parametre une position p) et de le reutiliser dans les 3 fonctions de l'exo 1
 
genre ce que je faisait :
 

 
puis appeller cette fonction a chauqe fois que t'en a besoin :
 

 
 
ça te simplifierait grandement la tâche (surtout que t'a pas besoin (d'après ton énoncé) de faire l'allocation ni l'affectation des valeurs du noeud.

Moi je dissocierais même l'insertion de la création histoire d'être le plus atomique possible...