salut

s'il vous plaît ,j'ai un probleme avec une fonction qui doit ajouter une structure ( appelle point ) dans une liste chainee tout en la triant ..

j'ai essayer de faire le programme ca se compile mais ca ma marche pas .. il m'envoie un message ( " segmentation fault ") ;

voici le code de la structure point :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
typedef struct point {  
 
        float x,y;
        struct point *psuiv;
    }point;
on dois cree une liste chainnee avec ces point bien évidement ..
la fonction qui ajoute un point a la structure ;
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
point *ajoutpt (point *maliste ,float r ,float t){
                    point *nouv;
                    nouv=(point*)malloc(sizeof(point*));
                    nouv->x=r;
                    nouv->y=t;
               if (maliste==NULL)
                     {
                     nouv->psuiv=NULL;
                     return nouv;
                     }
                if  ( condition sur la position == 1) {      //  mon point est dans la derniere position 
                                        nouv->psuiv=maliste;
                                        return nouv ;
                } else {
                                         free (nouv);
                                         maliste->psuiv=ajoutpt(maliste->psuiv,r,t);
                                         return maliste;    
 
}}
dans la fonction main je devais declarer un tableau de structure de donnee ( car on aurai besoin de plusieurs plusieurs suite de points ) donc j'ai mis :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
 
point *listept[M];   // avec M le nombre de liste qu'on dois avoire il est de fini par define au debut du programme
puis le remplissage des listes
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
    for (k=0;k<M;k++){ 
             listept[i]=NULL;
            for (i=0;i<M;i++){
                       // chargement d'un point
                        listept[k]=ajoutpt(listept[k],var,d[k].a*var +d[k].b);
                        fprintf (stderr,"%.2f ; ",var); }}
et voila ce que m'affiche la console :s :



Desole si c'est un peu en désordre c'est la premiere fois que j'ose ecrire quelque chose dans un forum .desole pour ceux a qui mon probleme paraîtra un peu bette :p , je ne suis qu'un debutant .
le code en entier pour les plus curieux ( c'est un probleme des structures reticulees ) :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#define N 6
#define M 15
 
typedef struct point {  // definition de la structure point
 
        float x,y;
        struct point *psuiv;
    }point;
 
typedef struct droite {  // creation structure d'une droite k droites
 
        float a,b,c;                // aX+b=cY
        int i,j;            // indice des point qui ont cree la droite
    }droite;
 
double intersection(float a1,float b1,float c1,float a2,float b2,float c2){ // marche Bien !!  // retourne l'abssice du pt d'intersection
                    if ( c1 == 0 ){          // cas droite x=valeur
                        if (c2 != 0){
                            return b1;
                    }}
                    if ( c2 == 0 ){
                            return b2;
                            }
                    else{
                            return ((b1 - b2 )/( a2 - a1));
                    }
                    }
 
 
 
point *ajoutpt (point *maliste,float r,float t){
                    point *nouv;
                    nouv=(point*)malloc(sizeof(point*));
                    nouv->x=r;
                    nouv->y=t;
 
                    int z;
 
    if (maliste==NULL)
    {
            nouv->psuiv=NULL;
            return nouv;
    }
    else
    {
                    if (r < (*maliste).x){
                        if (t < (*maliste).y){
                            z=1;
                        }else{
                            z=0;
                        }
                        }else{
                            if(t>(*maliste).y){
                                 z=1;
                            }else{
                                 z=0 ;
                        }
                    }
 
            if ( z==1){
                    nouv->psuiv=maliste;
                    return nouv;
            }else{
                free (nouv);
                maliste->psuiv=ajoutpt(maliste->psuiv,r,t);
                return maliste;
            }
    }
}
 
 
 
 
 
 
 
int main()
{
    int i,j,k,taille;
    float var;
    point p[N];
    droite d[M];
    srand (time (NULL));
    for (i=0;i<6;i++){  //generer des points ;
    p[i].x=rand()%20;
    p[i].y=rand()%20;
    printf("le point[%d] %f %f  \n",i,p[i].x,p[i].y);
    }
    // Remplire le tableau des Droites
    for (i=0;i<N-1;i++){
        for (j=i+1;j<N;j++){
            if (i!=j){
            if (p[j].x == p[i].x  ){   // probleme avec la droite de type x= valeur ;
                                d[taille].a=1;
                                d[taille].b=p[i].x;
                                d[taille].c=0;
            }else{
            d[taille].a= ( p[j].y - p[i].y) / ( p[j].x - p[i].x);
            d[taille].b=   p[j].y - d[taille].a*p[j].x;
            d[taille].c= 1;
            }
            d[taille].i=i;
            d[taille].j=j;
            printf ("%.2f %.2f %.2f %d %d: la droite [%d] \n",d[taille].a,d[taille].b,d[taille].c,d[taille].i,d[taille].j,taille); // TESTE
            taille++;
            }
        }
      }
 
 
 
    //les points d'intersectionintersection
    point *listept[M];
 
    for (k=0;k<M;k++){          
            listept[k]=NULL;
            for (i=0;i<M;i++){
 
                    if (d[i].i!=d[k].i){
                              if (d[i].i!=d[k].j){
                                    if (d[i].j!=d[k].j){
                                        if (d[i].j!=d[k].i){
 
                    if(d[i].a != d[k].a)         //parallelisme
                        {
                        if ( d[k].c == 0 ){          // cas droite x=valeur
                        if ( d[i].c != 0){
                            var=d[i].c;
                        }}
                        if ( d[i].c  == 0 ){
                            var=d[k].c;
                            }
                        else{
                            var=((d[k].b-d[i].b )/(d[i].a-d[k].a ));
                        }
 
 
                        listept[i]=ajoutpt(listept[i],var,d[k].a*var +d[k].b);
                        fprintf (stderr,"%.2f ; ",var);
                        }
                    }}}}}
            }
 
    return 0;
 
    }
Merci a vous