Bonjours j´ ai un gros probleme avec les listes doublements chainees en fait je comprend le principe mais ce que je ne comprend pas c est comment on les creer car si par exemple je veux creer
1->2->3->4->5
a chaque fois on fait un malloc et la nouvelle valleur est effacer non?
sinon vous pouvez me montrer un exemple simple pour que je comprenne (un exemple qui creer une liste doublement chainer pas qui insere)
merci pour votre aide
(desole pour les faute mais j ecrit avec un clavier americain)
bye

Une liste doublement chainée, c´est une structure :

struct chaine
{
T elem;
struct chaine* prec;
struct chaine* suiv;
};

(tu remplaces T par ce que tu veux, int, double, float, pour faire une liste chainée de int, de double, de float, ...)

tu as aussi 2 pointeurs.

Quand tu ajoutes un élément, tu malloc la struct (sans rien détruire), tu mets l´élément a jour, et tu fais crée les liens (pour les 2 pointeurs).

Donc quand tu ajoutes un élément, tu n´effaces rien, tu malloc une nouvelle maille, et tu lie aux autres.
Evidemment, les anciens liens des anciennes mailles peuvent avoir changé (pour pointer sur la nouvelle au lieu de NULL, ou d´une autre)

"Une liste doublement chainée, c´est une structure : "

-->

Une liste chainée, c´est un ensemble de mailles, et chaque maille est la structure suivante :

struct chaine
{
T elem;
struct chaine* prec;
struct chaine* suiv;
};

Ben en fait ce que je ne compremd pa c est quand on a rien et qu on veut creer une liste chainer par exemple
1->2->3->4
on fait on creer le premier maillons 1 puis on dit que le 2eme maillon c est 2
et si je fait a chaque fois et que j ai nouveau = (int *)malloc(sizeof tab) nouveau est effecer a chaque tour de boucle non?

au début tu n´as rien
Ta liste est un pointeur M sur une maille, au début, il pointe sur NULL.

Quand tu crées un éléments tu fais un malloc de la structure, tu ranges ton int, et tu fais pointer prec et suiv (les pointeurs de la structure) sur NULL (pas de précédent, pas de suivant), et M pointe sur cette maille.

Quand tu recrées un éléments, tu refais un malloc : tu alloues une 2e structure, et tu mets les pointeurs en place de façon a ce que le prec de la nouvelle structure pointe sur la premiere, et le suiv de l´ancienne pointe sur la nouvelle.

Je vais essayer de trouver un site, ce sera plus clair que de faire un exposé interminable sur le forum

http://fr.wikipedia.org/wg/wiki/Liste_cha%C3%AEn%C3%A9e

Apres, si tu as des questions moins vagues, j´y répondrai mais les questions trop vagues demandent trop de temps pour répondre.
Relis ton cours et dis nous sur quel point exactement tu bloques

Pour répondre a ta question du dessus :

Oui, a chaque fois que tu ajoutes un élément, tu fais un malloc

si j´ai bien compris ta question, ton problème, c´est le pointeur nouveau.

Effectivement, ton pointeur nouveau, ou ce que tu veux, qui pointe vers ta structure, ne pointe plus vers l´ancien élément (le 1 dans ton exemple, quand tu crée le 2), mais l´élément lui même n´est pas effacé (pour ça, il faut un appel à la fonction free). Or, avant de perdre son pointeur, tu le mets dans un pointeur temporaire (par exemple chaine* ancien), et ensuite, quand tu as nouveau (après l´appel à malloc), tu fait nouveau->prec = ancien; et ancien->suiv = nouveau; comme ça, tu peut te déplacer dans ta chaine à l´aide de ces pointeurs.

merci j ai un peu mieux compris
par contre j ai essayer de faire une liste chainer du type 1->2->3->4->5 ect..
mon programme bloc et je ne sais pas pourquoi
voici mon programme:

1. include <stdio.h>
2. include <stdlib.h>

typedef struct noeud {
int nbre;
struct noeud *pred;
struct noeud *suiv; }noeud;

noeud * debut;

noeud * init(void){
noeud * nouveau;
debut= NULL;
nouveau= (noeud *)malloc(sizeof(noeud));
nouveau->nbre=0;
nouveau->pred=nouveau->suiv;
nouveau->suiv=nouveau->pred;
debut=nouveau;
return (nouveau);
}
void creer(noeud * nouveau){
int i;
noeud * nouveaux;
nouveaux= (noeud *)malloc(sizeof(noeud));
nouveau->pred=NULL;
nouveau->suiv=nouveaux->pred;
debut=nouveau;
for(i=1;i<5;i++){
nouveaux= (noeud *)malloc(sizeof(noeud));
nouveaux->nbre=i;
nouveau->suiv=nouveaux->pred;
nouveaux->pred=nouveau->suiv;
nouveaux->suiv=debut;
nouveau=nouveaux;
printf("Nbre %d ",nouveaux->nbre);
}
}

void afficher(void){
noeud * nouveau;
nouveau=debut;)
do{
printf("Nbre %d ",nouveau->nbre);
nouveau=nouveau->suiv;
}
while(nouveau!=debut);
}

int main(void){)
noeud * nouveau;
nouveau=init();
creer(nouveau);
afficher();
return 0;
}

qd je compile il me met:
Erreur de segmentation (core dumped)

merci pour votre aide

:up

tu abuses d´upper alors que ton topic est premier de la liste!

si tu fais:
noeud * debut;
debut=nouveau;
Cela veut dire que tu n´as qu´une seule lsite chainé dans ton programme.

nouveau= (noeud *)malloc(sizeof(noeud));
nouveau->nbre=0;
nouveau->pred=nouveau->suiv;
Et qu´est ce que ca vaut nouveau->suiv au moment ou tu fais ca?

En fait c est mon prof qui m a dit qu il fallait creer le premier maillon cyclyque mais j ai regarder a l initialisation c est bon debut->nbre vaut bien 0 je pense qu il doit y avoir un problem de chainage mais je ne void pas ou

Pour bien comprendre, fait des dump :
c´est a dire que tu fais des printf ou des fprintf

--> Quand tu fais un malloc, fais afficher l´adresse sur laquelle tu as fait le malloc :

nouveau= (noeud *)malloc(sizeof(noeud));
printf("nouveau malloc : %p\n",nouveau);

Puis, quand tu ajoutes un element, fait afficher tes pointeurs :
printf("neud adresse : %p, val = %d, prec = %p, suiv =
%p\n",nouveau,nouveau->val,nouveau->pred,nouveau->
suiv);

Ce sera comme ça que tu verras exactement ce que tu fais

je vais citer le meme passage que godrik puisque c´est celui qui pose probleme en premier.
nouveau= (noeud *)malloc(sizeof(noeud));
nouveau->nbre=0;
nouveau->pred=nouveau->suiv;
Et qu´est ce que ca vaut nouveau->suiv au moment ou tu fais ca?
ton prof dis que ta chaine doit etre cyclique, tres bien mais cela signifie que (au debut) nouveau->suiv pointe sur nouveau et de meme pour nouveau->prec
nouveau->suiv = nouveau->prec = nouveau;

par la suite, pour ajouter un maillon (au debut par exemple), tu le fais de cette maniere:
le principe est de
- creer un nouveau maillon
- "decrocher" un "coté" d´un maillon de la chaine pour inserer le nouveau et refermer la chaine.

(fait des dessins sur du papier ça aide beaucoup pour voir les choses qu´il faut changer dans les differents elements de ta chaine)

je metrais du code si tu reste bloqué.

http://img451.imageshack.us/img451/9604/dbchainedn2.png

sublimissime dessins qui m´a permis de me rendre compte que je m´étais trompé dans le code que j´ai failli te mettre dans mon précédent post...

c est bon ca marche enfin!!!!!!!!!!!!!!
j ai compris ce qui n allait pas
c est qd j inserai un chainons je faiait:
nouveau->suiv=nouveaux->pred;
nouveaux->pred=nouveau->suiv;
fallait faire :
nouveau->suiv=nouveaux;
nouveaux->pred=nouveau;

a vous tous