inserer element dans une liste

Version imprimable

salut c'est encore moi ! j'ai essayé de coder une fonction qui insere un element dans une liste chainée suivant son indice,j'ai utilisé un passage par adresse mais ça n'a pas marché ,j'ai alors essayé un passage par valeur mais j'ai eu le meme probleme:( .
Svp est ce que vous pouvez m'exlpiquer mes erreurs pour que je les corriges.
merci
Code:

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 //passage par adresse void inserer(cellule **l,type elmt,int index) { int i=0; cellule *nv=NULL,*p=NULL; nv=malloc(sizeof(cellule)); if (listeestvide(*l)|| index<0) // listeestvide retourne 1 elle est vide sinon -1 { exit(EXIT_FAILURE); } p=*l; while(p!=NULL && i!=index) { i++; p=p->suiv; } if (i==index) { nv->suiv=p->suiv; p->suiv=nv; nv->data=elmt; } } //passage par valeur cellule* inserer(cellule *l,type elmt,int index) { int i=0; cellule *nv=NULL,*p=NULL; nv=malloc(sizeof(cellule)); if (listeestvide(l)|| index<0) // listeestvide retourne 1 elle est vide sinon -1 { return NULL; } p=l; while(p!=NULL && i!=index) { i++; p=p->suiv; } if (i==index) { nv->suiv=p->suiv; p->suiv=nv; nv->data=elmt; } return l; }

04/12/2006, 22h39
zooro

Code:

if (i=index)

Tu voulais sûrement écrire :

Code:

if (i==index)

non ?
04/12/2006, 22h44
hunter99

oui je l'ai modifié mais ça n'a pas resolu le probleme :arf:
04/12/2006, 22h57
coca25
je sais pas si c'est l'erreur qui te bloque, mais dans le code qui suit, tu peux avoir p=NULL et tu essayes d'acceder à p->suiv
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 p=l; while(p!=NULL && i!=index) { i++; p=p->suiv; } if (i==index) { nv->suiv=p->suiv; p->suiv=nv; nv->data=elmt; }
la premiere fonction ne sert à rien, tu as déjà l'adresse de la cellule avec cellule * c'est suffisant
04/12/2006, 22h58
zooro
Tu veux dire quoi par "ça n'a pas marché" ?
1. Ta liste n'est pas modifiée, ni pour une insertion en tête, ni en queue, ni au milieu ?
2. L'insertion se fait, mais pas où tu le souhaites ?
3. Le code ne compile pas ?
4. Tu as une erreur de segmentation ?
5. Obiwan Kenobi ?
04/12/2006, 23h32
hunter99

ça se compile mais l'insertion ne se fait pas toujours comme je veut:( :( :(

j'ai essayé de modifier le code , c'est un peu mieux mais ça donne parfois des resultat qui se repete!

Code:

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
 
void inserer(cellule **l,type elmt,int index)
{	
	int i=0;
	cellule *nv=NULL,*p=NULL;
 
	nv=malloc(sizeof(cellule));
	if (index<0)
	{
		printf("L'index doit etre superieur ou egal a 0\n,ARRET DU PROGRAMME\n");
		exit(EXIT_FAILURE);
	}
 
	if (index==0)
	{
			ajoutertete(l,elmt);//ajoute l'element a la tete de la liste
 
	}
 
	if (index == taille(*l))//taille retourne la taille de la liste
	{
		ajouterfin(l,elmt);
	}
	if (index>0 && index <taille(*l))
	{
		p=*l;
		while(p!=NULL && i!=index)
		{
			i++;
			p=p->suiv;
		}
 
			nv->suiv=p->suiv;
			p->suiv=nv;
			nv->data=elmt;
	}
	if (index==taille(*l))
	{
		ajouterfin(l,elmt);//ajoute l'element a la fin de la liste
	}
	if (index>taille(*l))
	{
		printf("Position inexistante ARRET DU PROGRAMME EN COURS\n");
		exit(EXIT_FAILURE);
	}
 
}

a mon avis j'ai un probleme dans les conditions sur l'index mais je ne parvient pas a le deceler :roll:
merci

Code:

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
void inserer(cellule **l ,type elmt,int index)
{	
	int i=0;
	cellule *nv=NULL,*p=NULL;
		
	nv=malloc(sizeof(cellule));
	if (index<0)
	{
		printf("L'index doit etre superieur ou egal a 0\n,ARRET DU PROGRAMME\n");
		exit(EXIT_FAILURE);
	}
 
	if (index==0)
	{
			ajoutertete(l,elmt);//ajoute l'element a la tete de la liste
		
	}
		
	if (index == taille(*l))//taille retourne la taille de la liste
	{
		ajouterfin(l,elmt);  // la tu ajoute l'element dans la liste taille est augmenté de 1
	}
	if (index>0 && index <taille(*l)) // du coup index devient < taille
	{
// et donc tu le rajoutes une 2eme fois
		p=*l;
		while(p!=NULL && i!=index)
		{
			i++;
			p=p->suiv;
		}
	
			nv->suiv=p->suiv;
			p->suiv=nv;
			nv->data=elmt;
	}
        // Cette condition ne sert à rien
	if (index==taille(*l))
	{
		ajouterfin(l,elmt);//ajoute l'element a la fin de la liste
	}
	if (index>taille(*l))
	{
		printf("Position inexistante ARRET DU PROGRAMME EN COURS\n");
		exit(EXIT_FAILURE);
	}
 
}

des return serait plus appropriés pour pouvoir libérer la mémoire en fin de programme.

Il y a des obscurités dans le but du code :
S'agit-il de placer un nouvel élément dans la liste à la position FINALE spécifiée par index ? Il me semble que si ce code place pour index == 0 l'élément en tête de la liste, pour les autres valeurs, il le place derrière l'élément actuellement en position index, ce qui place le nouveau en position finale index+1. Si c'est le cas, on ne peut placer un élément en position finale 1. Il faut s'assurer que index est bien la position finale et autoriser pour la valeur maximum d'index le nombre d'éléments dans la liste.
Il s'agit selon toutes apparences d'une liste simplement chaînée. Le code proposé est compliqué par le fait qu'il différencie le cas de l'insertion au milieu et le cas de l'insertion en queue alors que la procédure est la même. L'insertion en tête bénéficie à juste titre d'un traitement particulier.
Le malloc intervient très tôt dans le code, alors qu'on ne sait pas si index est correct, ce qui devrait conduire à introduire un code de récupération en cas d'impossibilité et compliquer encore les choses. La fonction, au lieu d'avorter brutalement le programme devrait renvoyer en cas d'impossibilité NULL et sinon un pointeur sur l'élément créé, ce qui laisse à l'utilisateur la possibilité d'intervenir en cas d'erreur.
Je verrais qq chose du genre :
Code:

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 cellule * inserer(cellule **l ,type elmt,int index) { int i=0; cellule *nv = NULL; cellule *p = *l; while(p!=NULL && i<index) // rechercher p en position 0 ou index-1 { i++; if(i<index)p = p->suiv; } if(i==index) { nv=malloc(sizeof(cellule)); if(nv != NULL) { nv->data=elmt; nv->suiv = NULL; if(index==0) // insertion en tête { nv->suiv =*l; *l = nv; } else // insertion ailleurs { nv->suiv = p->suiv; p->suiv=nv; } } } return nv; }

05/12/2006, 20h55
hunter99

Code:

if(i<index)p = p->suiv;

j'ai pas compris ce test :roll: est ce que tu peut m'expliquer svp ? :P
05/12/2006, 22h40
Médinoc
Code:

1 2 if(i<index) p = p->suiv;
Tant que i est inférieur à index [et qu'on a toujours des éléments], on passe à l'émément suivant.