DEVOIR sur les LISTES CHAINEES!!!(aidez-moi!)
Fermé
arana
Messages postés
7
Date d'inscription
mercredi 21 novembre 2007
Statut
Membre
Dernière intervention
19 décembre 2007
-
19 déc. 2007 à 12:48
arana Messages postés 7 Date d'inscription mercredi 21 novembre 2007 Statut Membre Dernière intervention 19 décembre 2007 - 19 déc. 2007 à 16:57
arana Messages postés 7 Date d'inscription mercredi 21 novembre 2007 Statut Membre Dernière intervention 19 décembre 2007 - 19 déc. 2007 à 16:57
A voir également:
- DEVOIR sur les LISTES CHAINEES!!!(aidez-moi!)
- Triez la liste comme sur cette illustration (attention, on ne voit que le début …). quel est le mot formé par les 6 dernières lettres de la colonne code ? - Forum Excel
- Le fichier contient une liste de prénoms. triez ce tableau par ordre alphabétique des prénoms. quel mot est formé par les 6 premières lettres de la colonne code ? - Forum Bureautique
- Comment faire une liste déroulante sur excel - Guide
- Les listes doublement chainées en c - Astuces et Solutions
- Les listes simplement chainées en c - Astuces et Solutions
7 réponses
SebManfred
Messages postés
484
Date d'inscription
mardi 28 août 2007
Statut
Membre
Dernière intervention
20 mai 2011
128
19 déc. 2007 à 12:59
19 déc. 2007 à 12:59
Salut,
permier truc : je ne vais pas te donner la solution, mais je peux te donner des pistes ou des conseils.
ensuite, bien comprendre l'énoncé : il s'agit, pour la question a, de donner une liste qui ne comprend que les éléments qui sont à la fois dans ta liste L1 et dans ta liste L2, et pour la question b, donner une liste qui contient tous les éléments contenus dans L1, tous les éléments contenus dans L2, mais en faisant en sorte que les éléments qui sont à la fois dans L1 ET L2 n'apparaissent qu'une seule fois
pour ma part, je sais que quand j'ai du mal avec les listes chainées, je me fais des petits dessins avec les pointeurs de tête, les différents éléments avec les pointeurs vers les précédents et suivants, le pointeur courant, etc..., et puis j'exécute sur le dessin en pas à pas mes fonction de navigation dans ma (ou mes) listes.
sinon, ou en es-tu de tes fonctions? as-tu déjà écrit quelque chose?
permier truc : je ne vais pas te donner la solution, mais je peux te donner des pistes ou des conseils.
ensuite, bien comprendre l'énoncé : il s'agit, pour la question a, de donner une liste qui ne comprend que les éléments qui sont à la fois dans ta liste L1 et dans ta liste L2, et pour la question b, donner une liste qui contient tous les éléments contenus dans L1, tous les éléments contenus dans L2, mais en faisant en sorte que les éléments qui sont à la fois dans L1 ET L2 n'apparaissent qu'une seule fois
pour ma part, je sais que quand j'ai du mal avec les listes chainées, je me fais des petits dessins avec les pointeurs de tête, les différents éléments avec les pointeurs vers les précédents et suivants, le pointeur courant, etc..., et puis j'exécute sur le dessin en pas à pas mes fonction de navigation dans ma (ou mes) listes.
sinon, ou en es-tu de tes fonctions? as-tu déjà écrit quelque chose?
SebManfred
Messages postés
484
Date d'inscription
mardi 28 août 2007
Statut
Membre
Dernière intervention
20 mai 2011
128
19 déc. 2007 à 13:59
19 déc. 2007 à 13:59
tout d'abord, qu'est-ce que tu attend de ta fonction?
qu'est-ce que tu veux pouvoir y passer comme arguments et qu'est-ce que tu attends qu'elle te retourne?
comment as-tu prototypé ta structure list?
là, tu as une fonction à laquelle tu passes deux variables dont je ne connais pas le type, tu mets à jour ces variables avec d'autres variables apparament locales à ta fonction et qui ne sont ni déclarées ni initialisées. donc, c'est normal que ton compilateur te jette.
essaie de voir ça du point de vue utilisation de ta fonction dans ton main : ton main va avoir à faire appel à ta fonction, il aura deux listes et voudra en avoir une troisième issue des deux premières.
donc, il faut qu'en paramètre, tu passes à ta fonction "quelque chose" qui puisse lui permettre d'utiliser tes listes, et qu'en retour, ta fonction te retourne "quelque chose" qui puisse te permettre de travailler sur la liste créée.
ensuite, et seulement ensuite, on passera à l'implémentation de ta fonction
ce que je te demande pour l'instant, c'est
- un prototype pour ta structure
- un main vide
- la déclaration de tes fonctions et leurs carcasses vides
qu'est-ce que tu veux pouvoir y passer comme arguments et qu'est-ce que tu attends qu'elle te retourne?
comment as-tu prototypé ta structure list?
là, tu as une fonction à laquelle tu passes deux variables dont je ne connais pas le type, tu mets à jour ces variables avec d'autres variables apparament locales à ta fonction et qui ne sont ni déclarées ni initialisées. donc, c'est normal que ton compilateur te jette.
essaie de voir ça du point de vue utilisation de ta fonction dans ton main : ton main va avoir à faire appel à ta fonction, il aura deux listes et voudra en avoir une troisième issue des deux premières.
donc, il faut qu'en paramètre, tu passes à ta fonction "quelque chose" qui puisse lui permettre d'utiliser tes listes, et qu'en retour, ta fonction te retourne "quelque chose" qui puisse te permettre de travailler sur la liste créée.
ensuite, et seulement ensuite, on passera à l'implémentation de ta fonction
ce que je te demande pour l'instant, c'est
- un prototype pour ta structure
- un main vide
- la déclaration de tes fonctions et leurs carcasses vides
arana
Messages postés
7
Date d'inscription
mercredi 21 novembre 2007
Statut
Membre
Dernière intervention
19 décembre 2007
19 déc. 2007 à 14:46
19 déc. 2007 à 14:46
j'attends de ma fonction qu'elle m'affiche l'intesection des deux listes L1 et L2, donc ce que j'ai compris c'est qu'il me faudrait créer une troisième lste que j'ai appelé L qui contient l'intersection des deux listes L1 et L2 qui sont apparemment déclarées, par contre il m'a fallu déclaré la liste d'intersection L ...
là, tu as une fonction à laquelle tu passes deux variables dont je ne connais pas le type, tu mets à jour ces variables avec d'autres variables apparament locales à ta fonction et qui ne sont ni déclarées ni initialisées. donc, c'est normal que ton compilateur te jette.
pour les deux variables tu parlais de premier et r si c oui alors vous avez raison g sauté la partie déclaration donc là g refai mon exo et voilà c ke g
struct list-cell l
{int info;
struct list-cell*suiv;
};
type def struct list-cell*list;
int intersection(listeL1,listeL2);
{int premier;
int r;
listeL1=p;
listeL2=q;
premier=NULL;
while((p!=NULL)&&(q!=NULL)&&(p->info!=q->info))
{
q=q->suiv;
};
if(p->info=q->info)
{
r=p->info;
l=malloc(sizeof(struct list cell));
l->suiv=premier;
premier=l;
stcpy(l->info,r);
l->suiv=l;
};
p=p->suiv;
alors qu'en di tu de ceci..!!!!
là, tu as une fonction à laquelle tu passes deux variables dont je ne connais pas le type, tu mets à jour ces variables avec d'autres variables apparament locales à ta fonction et qui ne sont ni déclarées ni initialisées. donc, c'est normal que ton compilateur te jette.
pour les deux variables tu parlais de premier et r si c oui alors vous avez raison g sauté la partie déclaration donc là g refai mon exo et voilà c ke g
struct list-cell l
{int info;
struct list-cell*suiv;
};
type def struct list-cell*list;
int intersection(listeL1,listeL2);
{int premier;
int r;
listeL1=p;
listeL2=q;
premier=NULL;
while((p!=NULL)&&(q!=NULL)&&(p->info!=q->info))
{
q=q->suiv;
};
if(p->info=q->info)
{
r=p->info;
l=malloc(sizeof(struct list cell));
l->suiv=premier;
premier=l;
stcpy(l->info,r);
l->suiv=l;
};
p=p->suiv;
alors qu'en di tu de ceci..!!!!
lami20j
Messages postés
21331
Date d'inscription
jeudi 4 novembre 2004
Statut
Modérateur, Contributeur sécurité
Dernière intervention
30 octobre 2019
3 567
>
arana
Messages postés
7
Date d'inscription
mercredi 21 novembre 2007
Statut
Membre
Dernière intervention
19 décembre 2007
19 déc. 2007 à 14:55
19 déc. 2007 à 14:55
Salut,
il faut penser à la comparaison des éléments de tes listes L1 et L2
Si par exemple tu as
A = {1,2,3} et B = {3,4,5}
l'union sera U = {1,2,3,4,5} donc il faut faire une comparaison pour ne pas avoir 3 deux fois
pour l'intersection tu ne cherchera que les éléments communs mais l'existence dois toujours être verifier pour ne pas avoir 2 éléments
donc I = {3}
Dans mon message je t'ai donner l'algo de pour l'union et l'intersection.
il faut penser à la comparaison des éléments de tes listes L1 et L2
Si par exemple tu as
A = {1,2,3} et B = {3,4,5}
l'union sera U = {1,2,3,4,5} donc il faut faire une comparaison pour ne pas avoir 3 deux fois
pour l'intersection tu ne cherchera que les éléments communs mais l'existence dois toujours être verifier pour ne pas avoir 2 éléments
donc I = {3}
Dans mon message je t'ai donner l'algo de pour l'union et l'intersection.
arana
Messages postés
7
Date d'inscription
mercredi 21 novembre 2007
Statut
Membre
Dernière intervention
19 décembre 2007
>
lami20j
Messages postés
21331
Date d'inscription
jeudi 4 novembre 2004
Statut
Modérateur, Contributeur sécurité
Dernière intervention
30 octobre 2019
19 déc. 2007 à 15:07
19 déc. 2007 à 15:07
d'abord MERCI pour le site ,il me serait d'une très grande utilité!!
OUI chui d'accord avc c ke vs avez écrit ci dessus; effectivement il nous faudrait éviter les répétitions pour cela g choisi un entier que g appelé r et qui est l'élément commun de L1 et L2 et j l'ai mis ds le champ info de ma liste d'intersection l...
mais ché po si ma fonction est exacte à 100pr 100...
OUI chui d'accord avc c ke vs avez écrit ci dessus; effectivement il nous faudrait éviter les répétitions pour cela g choisi un entier que g appelé r et qui est l'élément commun de L1 et L2 et j l'ai mis ds le champ info de ma liste d'intersection l...
mais ché po si ma fonction est exacte à 100pr 100...
lami20j
Messages postés
21331
Date d'inscription
jeudi 4 novembre 2004
Statut
Modérateur, Contributeur sécurité
Dernière intervention
30 octobre 2019
3 567
19 déc. 2007 à 14:09
19 déc. 2007 à 14:09
Salut,
pour les liste simplement chaînée
pour les ensemble je suis en train d'écrire un tutoriel, voici le code
j'ai mis en gras les fonctions pour l'intersection et l'union
ensemble.h
pour les liste simplement chaînée
pour les ensemble je suis en train d'écrire un tutoriel, voici le code
j'ai mis en gras les fonctions pour l'intersection et l'union
ensemble.h
/*****************\
* ensemble.h *
\*****************/
typedef struct ListeElement{
char *nom;
struct ListeElement *suivant;
}Element;
typedef struct ListeRepere{
int taille;
Element *debut;
Element *fin;
}Liste;
/* insertion dans liste */
int insertion (Liste *liste,char *nom);
/* suppression dans liste */
int suppression (Liste *liste);
/* traitement des ensembles */
typedef Liste Ensemble;
void init_ens(Ensemble *ens);
int insert_ens(Ensemble *ens, char *nom);
int suppr_ens(Ensemble *ens);
int ens_union (Ensemble *ens_u, Ensemble *ens1, Ensemble *ens2);
int ens_intersect (Ensemble *ens_i, Ensemble *ens1, Ensemble *ens2);
int ens_diff (Ensemble *ens_d, Ensemble *ens1, Ensemble *ens2);
int ens_sous_ens (Ensemble *ens1, Ensemble *ens2);
int ens_egal_ens (Ensemble *ens1, Ensemble *ens2);
void affiche(Ensemble *ens);
void detruire(Ensemble *ens);
int existe (Ensemble *ens, char *nom);
Ensemble * alloc_ens(Ensemble *ens);
ensemble_function.h/**********************\
* ensemble_function.h *
\**********************/
/* insertion dans liste */
int insertion (Liste *liste,char *nom){
Element *nouveau_element;
Element *courant;
if((nouveau_element = (Element *) malloc (sizeof(Element)))
== NULL)
return -1;
if((nouveau_element->nom = (char *) malloc (50 * sizeof(char)))
== NULL)
return -1;
strcpy(nouveau_element->nom,nom);
if(liste->taille == 0){
liste->fin = nouveau_element;
nouveau_element->suivant = liste->debut;
liste->debut = nouveau_element;
} else { /* l'insertion se fera toujours à la fin */
courant = liste->fin;
nouveau_element->suivant = courant->suivant;
courant->suivant = nouveau_element;
liste->fin = nouveau_element;
}
liste->taille++;
return 0;
}
/* suppression dans liste */
int suppression (Liste *liste){
Element *supp_element;
supp_element = liste->debut;
liste->debut = liste->debut->suivant;
if(liste->taille == 1)
liste->fin = NULL;
free(supp_element->nom);
free(supp_element);
liste->taille--;
return 0;
}
/* traitement des ensembles */
void init_ens(Ensemble *ens){
ens->taille = 0;
ens->debut = NULL;
ens->fin = NULL;
}
/* insertion élément dans un ensemble */
int insert_ens(Ensemble *ens, char *nom){
if(existe(ens,nom))
return -1;
return insertion(ens,nom);
}
/* opérations avec ensemlbes */
int ens_union (Ensemble *ens_u, Ensemble *ens1, Ensemble *ens2){
Element *element;
for(element=ens1->debut;element != NULL;element = element->suivant)
insertion(ens_u,element->nom);
for(element=ens2->debut;element != NULL;element = element->suivant)
if(! existe(ens_u,element->nom))
insertion(ens_u,element->nom);
return 0;
}
int ens_intersect (Ensemble *ens_i, Ensemble *ens1, Ensemble *ens2){
Element *element;
for(element=ens1->debut;element != NULL;element = element->suivant)
if(existe(ens2,element->nom))
insertion(ens_i,element->nom);
return 0;
}
int ens_diff (Ensemble *ens_d, Ensemble *ens1, Ensemble *ens2){
Element *element;
for(element=ens1->debut;element != NULL;element=element->suivant)
if(! existe(ens2,element->nom))
insertion(ens_d,element->nom);
return 0;
}
int ens_sous_ens (Ensemble *ens1, Ensemble *ens2){
Element *element;
if(ens1->taille > ens2->taille)
return 0;
for(element=ens1->debut;element != NULL;element=element->suivant){
if(! existe(ens2,element->nom))
return 0;
}
return 1;
}
int ens_egal_ens (Ensemble *ens1, Ensemble *ens2);
void affiche(Ensemble *ens){
Element *element;
for(element=ens->debut;element != NULL;element=element->suivant)
printf("%s ",element->nom);
printf("\n");
}
int existe (Ensemble *ens, char *nom){
Element *element;
for(element=ens->debut;element != NULL;element=element->suivant)
if(strcmp(element->nom,nom) == 0)
return 1;
return 0;
}
void detruire(Ensemble *ens){
while(ens->taille > 0)
suppression(ens);
}
Ensemble * alloc_ens(Ensemble *ens){
if((ens = (Ensemble *) malloc (sizeof(Ensemble)))
== NULL)
return NULL;
return ens;
}
ensemble.c#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ensemble.h"
#include "ensemble_function.h"
int main()
{
char *nom;
Ensemble *ens;
Ensemble *ens2;
Ensemble *ens_u;
Ensemble *ens_i;
Ensemble *ens_d;
ens = alloc_ens(ens);
init_ens(ens);
ens2 = alloc_ens(ens2);
init_ens(ens2);
ens_u = alloc_ens(ens_u);
init_ens(ens_u);
ens_i = alloc_ens(ens_i);
init_ens(ens_i);
ens_d = alloc_ens(ens_d);
init_ens(ens_d);
if((nom = (char *) malloc (50 * sizeof(char)))
== NULL)
return -1;
printf("Entre un nom : ");
scanf("%s",nom);
insert_ens(ens,nom);
printf("Entre un nom : ");
scanf("%s",nom);
insert_ens(ens,nom);
printf("Entre un nom : ");
scanf("%s",nom);
insert_ens(ens,nom);
printf("***** ens1 *****\n");
affiche(ens);
printf("Entre un nom : ");
scanf("%s",nom);
insert_ens(ens2,nom);
printf("Entre un nom : ");
scanf("%s",nom);
insert_ens(ens2,nom);
printf("Entre un nom : ");
scanf("%s",nom);
insert_ens(ens2,nom);
printf("Entre un nom : ");
scanf("%s",nom);
insert_ens(ens2,nom);
printf("***** ens2 *****\n");
affiche(ens2);
//ens_union(ens_u,ens,ens2);
ens_union(ens_u,ens,ens2);
printf("***** l'UNION *****\n");
printf("%d\n",ens_u->taille);
affiche(ens_u);
//ens_intersect(ens_i,ens,ens2);
ens_intersect(ens_i,ens,ens2);
printf("*****l'INTERSECTION*****\n");
printf("%d\n",ens_i->taille);
affiche(ens_i);
//ens_diff(ens_d,ens,ens2);
ens_diff(ens_d,ens,ens2);
printf("*****la DIFFERENCE*****\n");
printf("%d\n",ens_d->taille);
affiche(ens_d);
// sous-ensemble
if(ens_sous_ens(ens,ens2))
printf("ens est sous-ensemble de ens2!\n");
else
printf("ens n'est pas un sous-ensemble de ens2!\n");
return 0;
}
lami20j
Messages postés
21331
Date d'inscription
jeudi 4 novembre 2004
Statut
Modérateur, Contributeur sécurité
Dernière intervention
30 octobre 2019
3 567
19 déc. 2007 à 14:17
19 déc. 2007 à 14:17
Si tu as besoin je pourrai t'expliquer, mais pas maintenant, je suis au boulot ;-)
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
SebManfred
Messages postés
484
Date d'inscription
mardi 28 août 2007
Statut
Membre
Dernière intervention
20 mai 2011
128
19 déc. 2007 à 15:03
19 déc. 2007 à 15:03
déjà, ne met pas de caractères du genre "-" dans tes noms de variables, types ou structures, le compilateur n'accepte pas.
si tu y tiens vraiment, remplace-les par "_", ça passera beaucoup mieux.
ensuite, quel est le prototype de ta fonction?
je voudrai voir un truc du genre
typedef struct nom_struct {
// données
};
type1 intersection(type2 ListeL1, type3 ListeL2);
type4 intersection(type5 ListeL1, type6 ListeL2);
int main(void)
{
return 0;
}
type1 intersection(ListeL1, ListeL2)
{
type1 retour;
// initialisation du retour en fonction de son type, à toi de le faire
return retour;
}
type4 intersection(ListeL1, ListeL2)
{
type4 retour;
// initialisation du retour en fonction de son type, à toi de le faire
return retour;
}
à toi de voir quels types donner à type1, type2, type3, type4, type5 et type6 pour pouvoir passer tes différents paramètres en pouvant les utiliser, et pour pouvoir également utiliser ton retour comme tu le souhaite...
l'écriture de tes fonctions viendra plus tard, tu ne peux pas écrire tes fonctions tant que tu ne sais pas ce qu'elles doivent faire, ni ce qu'elle prennent et rendent
on remplira le main plus tard, mais déjà, si tu écris tout correctement, ça devrait compiler
si tu y tiens vraiment, remplace-les par "_", ça passera beaucoup mieux.
ensuite, quel est le prototype de ta fonction?
je voudrai voir un truc du genre
typedef struct nom_struct {
// données
};
type1 intersection(type2 ListeL1, type3 ListeL2);
type4 intersection(type5 ListeL1, type6 ListeL2);
int main(void)
{
return 0;
}
type1 intersection(ListeL1, ListeL2)
{
type1 retour;
// initialisation du retour en fonction de son type, à toi de le faire
return retour;
}
type4 intersection(ListeL1, ListeL2)
{
type4 retour;
// initialisation du retour en fonction de son type, à toi de le faire
return retour;
}
à toi de voir quels types donner à type1, type2, type3, type4, type5 et type6 pour pouvoir passer tes différents paramètres en pouvant les utiliser, et pour pouvoir également utiliser ton retour comme tu le souhaite...
l'écriture de tes fonctions viendra plus tard, tu ne peux pas écrire tes fonctions tant que tu ne sais pas ce qu'elles doivent faire, ni ce qu'elle prennent et rendent
on remplira le main plus tard, mais déjà, si tu écris tout correctement, ça devrait compiler
arana
Messages postés
7
Date d'inscription
mercredi 21 novembre 2007
Statut
Membre
Dernière intervention
19 décembre 2007
19 déc. 2007 à 16:20
19 déc. 2007 à 16:20
REBONJOUR,
pr le prototype de la fonction g po très bien compris ce que vous voulez dire, mais d'habitude en TD on déclare la liste qu'on nous demande
de retrouver de la manièe suivante ,par exple ds l exo que g écris en haut d la page on doit retrouver d'abord la liste d'intersection de L1 et L2, DSL je vois po comment j pourrais faire pr la déclaration de L à part ceci:
struct cell
{int info;
struct cell*suiv;
};
type def struct cell*listeL;
int struct cell intersection(struct cellule listeL1,struct cellule listeL2);
pr le prototype de la fonction g po très bien compris ce que vous voulez dire, mais d'habitude en TD on déclare la liste qu'on nous demande
de retrouver de la manièe suivante ,par exple ds l exo que g écris en haut d la page on doit retrouver d'abord la liste d'intersection de L1 et L2, DSL je vois po comment j pourrais faire pr la déclaration de L à part ceci:
struct cell
{int info;
struct cell*suiv;
};
type def struct cell*listeL;
int struct cell intersection(struct cellule listeL1,struct cellule listeL2);
lami20j
Messages postés
21331
Date d'inscription
jeudi 4 novembre 2004
Statut
Modérateur, Contributeur sécurité
Dernière intervention
30 octobre 2019
3 567
19 déc. 2007 à 16:35
19 déc. 2007 à 16:35
Salut,
l'intersection est une liste Li
donc tu dois avoir plutôt
l'intersection est une liste Li
donc tu dois avoir plutôt
struct cell
{
int info;
struct cell*suiv;
};
typedef struct cell *listeL;
int intersection(listeL Li, listeL L1, listeL L2);
arana
Messages postés
7
Date d'inscription
mercredi 21 novembre 2007
Statut
Membre
Dernière intervention
19 décembre 2007
19 déc. 2007 à 16:42
19 déc. 2007 à 16:42
SALUT,
DONC d'après vous je dois po écrire
int struct cell intersection(struct cellule listeL1,struct cellule listeL2);
mais plutôt
int intersection(listeL Li, listeL L1, listeL L2);
et juste après j'écris ma fonction??!!!!!
DONC d'après vous je dois po écrire
int struct cell intersection(struct cellule listeL1,struct cellule listeL2);
mais plutôt
int intersection(listeL Li, listeL L1, listeL L2);
et juste après j'écris ma fonction??!!!!!
lami20j
Messages postés
21331
Date d'inscription
jeudi 4 novembre 2004
Statut
Modérateur, Contributeur sécurité
Dernière intervention
30 octobre 2019
3 567
19 déc. 2007 à 16:52
19 déc. 2007 à 16:52
Quand on écrit une fonction il faut d'abord penser de ce qu'on veux passer en parametre et aussi de la valeur qu'on veut renvoyer.
Si la fonction prends en paramètre les 2 listes et renvoi l'intersection alors on peut écrire
si on veut envoyer un entier 0 pour réussite et -1 pour echéc alors on peut écrire
en revanche int struct cell intersection(struct cellule listeL1,struct cellule listeL2);
on ne peux pas écrire puisque dans ce cas le type et int et le nom de la fonction sera separé par des espaces et ce n'est pas permis
il faut choisir :
- si je veux renvoyer une valeur int alors je mets comme type de la fonction int
- si je veux renvoyer une liste alors je mets le type comme liste
mais ta structure n'est qu'un élément de la liste
si tu veux utilser les listes chaînée tu dois utiliser au moins un pointeur qui pointe vers le 1er élément de la liste, sinon tu ne pourras pas parcourir la liste
Pourqouoi ne regardes-tu le tuto que je t'ai donnée, il y a aussi des images pour mieux comprendre ;-)
Si la fonction prends en paramètre les 2 listes et renvoi l'intersection alors on peut écrire
struct cell
{
int info;
struct cell*suiv;
};
typedef struct cell *listeL;
listeL intersection(listeL L1, listeL L2);
si on veut envoyer un entier 0 pour réussite et -1 pour echéc alors on peut écrire
struct cell
{
int info;
struct cell*suiv;
};
typedef struct cell *listeL;
int intersection(listeL Li, listeL L1, listeL L2);
en revanche int struct cell intersection(struct cellule listeL1,struct cellule listeL2);
on ne peux pas écrire puisque dans ce cas le type et int et le nom de la fonction sera separé par des espaces et ce n'est pas permis
il faut choisir :
- si je veux renvoyer une valeur int alors je mets comme type de la fonction int
- si je veux renvoyer une liste alors je mets le type comme liste
mais ta structure n'est qu'un élément de la liste
si tu veux utilser les listes chaînée tu dois utiliser au moins un pointeur qui pointe vers le 1er élément de la liste, sinon tu ne pourras pas parcourir la liste
Pourqouoi ne regardes-tu le tuto que je t'ai donnée, il y a aussi des images pour mieux comprendre ;-)
arana
Messages postés
7
Date d'inscription
mercredi 21 novembre 2007
Statut
Membre
Dernière intervention
19 décembre 2007
19 déc. 2007 à 16:57
19 déc. 2007 à 16:57
MERCI BEAUCOUP pour les indications, c plus clair maintenant !!!
j v jeter 1 coup d'oeil sur le site..
j v jeter 1 coup d'oeil sur le site..
19 déc. 2007 à 13:44
TOut d'abrd je te remercie de vouloir m'aider!!!
Chui tout à fait d'accord avec toi, le but n'est pas de copier la solution mais de bien comprendre et de discuter le problème!!!
j'ai en effet ,comme j l'ai signalé précedemment, travaillé et essayé de résoudre le problème...
ET J AI BIEN EVIDEMMENT ECRIT KELKE CHOSE DS MON BROUILLON ,voilà ou j'en sui:
int intersection(listeL1,listeL2)
{
listeL1=P;
listeL2=q;
listeL=l;
premier=NULL;
int r;
while((p!=NULL)&&(q!=NULL)&&(p->info!=q->info))
{
q=q->suiv;
};
if(p->info=q->info)
{
r=p->info;
l=malloc(sizeof(struct list cell));
l->suiv=premier;
premier=l;
stcpy(l->info,r);
l->suiv=l;
};
p=p->suiv;
q=q->suiv;
C EST CE QUE G REUSSI A FAIRE JUSQU A MAINTENANT !!!
pliiiiiiiiiizzz dites moi ou sont mes erreurs et ce que j devrai faire..
MERCI D AVANCE.