Bonjour,
je debute en C et je galère un peu pour trouver un problème de segmentation lors de l’exécution de mon main (la compilation se passe très bien). je pense que le problème vient de ma fonction cree_sequence, dans la boucle while plus exactement.
si quelqu'un peut m'aider svp pcq je n'y arrive pas.
Merci d'avance.

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
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
 
typedef struct base {
    char data;
    struct base * next;
} base;
 
typedef struct sequence {
    int nb_bases;
    base * debut;
    base * fin;
} sequence;
 
base * cree_base ( char c );
 
sequence  * cree_sequence( char s[] );
 
void affiche_sequence (sequence * s);
 
sequence  * concatene (sequence * adn, sequence * adn2);
 
void inversion (sequence * const s, int k);
 
int distance ( sequence * adn1, sequence * adn2);
 
base * cree_base ( char c ) {
    base * result = malloc (sizeof(base));
    result->data = c ;
    result->next = NULL ;
    return result;
};
 
sequence  * cree_sequence( char s[] ) {
    sequence * seq = malloc(sizeof(sequence));
    if(s[0]=='\0') { 
        seq->nb_bases=0; 
        seq->debut=NULL;
        seq->fin=NULL;
        return seq;
    }
    else { 
        base * debut=cree_base(s[0]);// on initialise notre sequence avec le premier caract��re de la chaine.
        seq->fin=debut;
        seq->debut=debut;
        seq->nb_bases=1;
        while (s[seq->nb_bases] =! '\0') {	 
            base * new = cree_base(s[seq->nb_bases]); 
            seq->fin->next=new;
            seq->fin=new;
            seq->nb_bases++;
        }
        return seq;
    }
};
 
void affiche_sequence (sequence * s) {
    base * courant;
    courant = s->debut;
    if (courant==NULL) { 
        printf("la liste est vide \n");
        return;
    }
    printf("NB de bases : %d\n",s->nb_bases);
    while (courant != NULL){
        printf (" %c ", courant->data);
        courant = courant->next;
    }
    printf("\n");
};
 
sequence  * concatene (sequence * adn, sequence * adn2) {
    adn->fin->next=adn2->debut;
    adn->fin=adn2->fin;
    return adn;
};
 
void inversion (sequence * const s, int k) {
    int i;
    base * tmp=s->debut;
    for (i=1;i<k;i++) tmp = tmp->next;
    char t = tmp->data;
    tmp->data=tmp->next->data;
    tmp->next->data=t; 
}
 
int distance ( sequence * adn1, sequence * adn2) {
    if (adn1->nb_bases != adn2->nb_bases) { 
        printf("les deux sequences n'ont pas la m��me taille");
        return -1;
    }
    int compteur=0;
    base * tmp1 = adn1->debut;
    base * tmp2 = adn2->debut;
    int i=adn1->nb_bases;
    while(i =! 1) { 
        if (tmp1->data =! tmp2->data) {compteur++;}
        tmp1=tmp1->next;
        tmp2=tmp2->next;
        i--;
    }
    return compteur;
 
 
}
int main ( void ) {
    sequence * adn = cree_sequence("ATTAGCCGTA");
    printf("%d\n",adn->nb_bases);
    affiche_sequence ( adn );
    sequence * adn2 = cree_sequence ( " TGCAAT " );
    affiche_sequence ( adn2 );
    concatene ( adn , adn2 );
    affiche_sequence ( adn );
    inversion ( adn , 4);
    affiche_sequence ( adn );
    return 0;
}