Liste chainée

Version imprimable

Liste chainée

salut svp j'arrive pas terminer mon travail :help:

voila l'exercice:
on considère une liste chainée simple L d'entiers. cette liste est accessible a partir de son premier élément dont l'adresse est stockée dans un pointeur nommé "tete".
écrire le programme qui permet d'éclater la liste L en deux liste L et L' de telle sorte que la liste L ne comporte que les entiers impairs tandis que la liste L' ne comporte que les entiers pairs.[/CODE]
et voila ce que j'ai pu faire::?

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
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
#include<stdio.h>
#include<stdlib.h>
 
typedef struct element *pelement;
typedef struct element {
    int val;
    pelement suiv;
} element;
 
typedef struct liste {
    pelement tete;					
    element queue;        
    int taille;
} liste;
 
void init_liste(liste *l);
void init_liste(liste *l){
    l->tete=NULL;
    l->taille=0;
}
void init(liste *l){
    l->tete=NULL;
    l->taille=0;
}
 
 
void creer_liste(liste*l,int taille){
    pelement nouv,cour;
    nouv=(pelement)malloc(sizeof(element));
    scanf("%d",&nouv->val);
    nouv->suiv=NULL;
    l->tete=nouv;
    for(int i=2;i<=taille;i++){
        cour=nouv;
        nouv=(pelement)malloc(sizeof(element));
        scanf("%d",&nouv->val);
        nouv->suiv=NULL;
        cour->suiv=nouv;
        l->taille=l->taille+1;
    }
}
 
void pair(liste *l, liste *p){
    pelement cour, pres;
    pelement nouv,courr;
    int pos=0;
 
    cour=l->tete;
 
    while (cour!=NULL ){ 
 
        if (cour->val%2 ==0) {              
            nouv=(pelement)malloc(sizeof(element));
            nouv->val = cour->val;
            nouv->suiv=NULL;
            p->tete=nouv;
            break;
        }
        cour=cour->suiv;
    } 
 
    while (cour!=NULL){ 
        pos=pos+1;     
        if (cour->val%2 ==0) { 
            //supprimer_elem(l,pos);                                  
            courr=nouv;
            nouv=(pelement)malloc(sizeof(element));
            nouv->val = cour->val;
            nouv->suiv=NULL;
            courr->suiv=nouv;
        } 
        cour=cour->suiv;
    }       
 
 
}
 
 
void afficher(liste *l){
    pelement cour;
    cour=l->tete;
    while (cour!=NULL)
    {
        printf("%d\n",cour->val);
        cour=cour->suiv;
    }
}
 
int main(){
    liste *L;
    liste *pairs;
    liste *impairs;
 
    L=(liste*)malloc(sizeof(liste));
    int size, pos;
    init_liste(L);	
    printf("---(1)- Phase de Creation : \n");
 
    printf("Donnez la taille de la liste a cree: \n");
    scanf("%d",&size);
    printf("Donner les elements de la liste a cree :\n");
    creer_liste(L,size);
 
    printf("---(2)- Phase de tri : \n");
    system("pause");
    init_liste(pairs);
 
    pair(L,pairs);
    printf("Voici liste L' qui comporte que les entier pairs : \n");
    afficher(pairs);
    printf("Voici liste L qui comporte que les entier impairs : \n");
    afficher(L);
 
    system("pause");
    return 0;
}

merci d'avance :merci:^^

Bonjour

Citation:

Envoyé par nissa_16

et voila ce que j'ai pu faire::?

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
int main(){
    liste *L;
    liste *pairs;
    liste *impairs;
    
    L=(liste*)malloc(sizeof(liste));
    /* 
        Mouais. Pourquoi déclarer un pointeur pour l'allouer de 1 ?
        Tu ne pouvais pas déclarer directement "liste L" ???
    */
    int size, pos;
    init_liste(L);	
    printf("---(1)- Phase de Creation : \n");
    
    printf("Donnez la taille de la liste a cree: \n");
    scanf("%d",&size);
    printf("Donner les elements de la liste a cree :\n");
    creer_liste(L,size);
    
    printf("---(2)- Phase de tri : \n");
    system("pause");
    init_liste(pairs);      // Mouais. Et "pairs" il est alloué dans le cloud ??? 
  
    pair(L,pairs);
    printf("Voici liste L' qui comporte que les entier pairs : \n");
    afficher(pairs);
    printf("Voici liste L qui comporte que les entier impairs : \n");
    afficher(L);

    system("pause");
    return 0;            // Surtout ne libère pas la mémoire allouée, ce serait trop bête que ton OS récupère sa pleine capacité...
}

T'as mes remarques dans ton code (et c'est du C, pas du SQL !!!)

12/01/2014, 19h37
nissa_16

Alors qu'est-ce que je peux faire au lieu d'allouer ?
12/01/2014, 22h16
Sve@r
Citation:

Envoyé par nissa_16

Alors qu'est-ce que je peux faire au lieu d'allouer ?

Je sais pas... utiliser une variable typée au lieu d'un pointeur...
Code:

1 2 3 4 5 6 7 8 int *pt; pt=malloc(sizeof(int)); if (pt) { (*pt)=123; printf("La valeur est %d\n", *pt); free(pt); }
Code:

1 2 3 int i; i=123; printf("La valeur est %d\n", i);
A toi de voir laquelle des deux écritures est la plus simple à mettre en oeuvre et à maintenir...
13/01/2014, 11h52
Médinoc
Ça, c'est vachement suspect:
Code:

1 2 3 4 5 typedef struct liste { pelement tete; element queue; /* <------- SUSPECT */ int taille; } liste;
Pourquoi une structure de gestion de la liste contiendrait-elle un chaînon?

Bonjour,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
    while (cour!=NULL ){ 
 
        if (cour->val%2 ==0) {              
            nouv=(pelement)malloc(sizeof(element));
            nouv->val = cour->val;
            nouv->suiv=NULL;
            p->tete=nouv;
            cour=cour->suiv; // cette ligne à ajouter sinon vous aurez toujours le premier élément qui sera dupliqué.
            break;
        }
        cour=cour->suiv;
    }

14/01/2014, 09h20
skeud

Je rappelle qu'avant de poster, il faut RECHERCHER!!!!!

En 2sec avec google et dvp: liste chainées

Et je pense que ceci pourra aussi grandement aider.