Liste verticale et horizontale

17 septembre 2020 à 20:02:24

Bonsoir, je dois creer une liste horizontale qui contient deux champs : le premier

champ contient un caractère et le deuxième champ contient l'adresse du

suivant et une liste verticale qui ne contient que des adresses: la première case contient

l'adresse de la tête de la liste horizontale, et la deuxième case contient

l'adresse du suivants mais je n'arrive toujours pas si vous pourriez m'aider s'il vous plait

struct ClisteA /*liste horizontale*/
{
    char element;
    struct ClisteA *suiv;
};

struct ClisteB /*liste verticale*/
{
    struct ClisteA *suivA;
    struct ClisteB *suivB;
};

int main()
{
    struct ClisteB *l;
    struct ClisteA *t, *p, *q;
    int n, m, i, j;

    printf("Donner le nombre de listes");
    scanf("%d", &n);

    for(i=0; i<n; i++)
    {
        printf("Donner le nombre d'elements de la liste");
        scanf("%d", &m);

        l = malloc(sizeof(struct ClisteB));
        t = l->suivA;
        t = malloc(sizeof(struct ClisteA));
        printf("Donner la valeur du 1er element");
        scanf("%c", t->element);
        q = t;
        for(j=1; j<m; j++)
        {
            p = malloc(sizeof(struct ClisteA));
            printf("Donner la valeur du %d eme element", j+1);
            scanf("%c", p->element);
            q->suiv = p;
            q = p;
        }
        q->suiv = NULL;
    }

    printf("Les elements de la liste\n");
    while(q != NULL)
    {
        printf("%5d", q->element);
        q = q->suiv;
    }
    printf("\n");

    return 0;
}

rouloude

17 septembre 2020 à 21:36:55

C'est cela :

 pointeur
 d'entrée
    | 
    | 
    | 
    | 
    V
  ,---,          ,---,   ,---,   ,---,     
  |   |--------->| a |-->| b |-->| c |-->NULL     
  '---'          '---'   '---'   '---'    
    | 
    V   
  ,---,          ,---,   ,---,   ,---,    
  |   |--------->| d |-->| e |-->| f |-->NULL    
  '---'          '---'   '---'   '---'    
    |   
    V   
  ,---,          ,---,   ,---,   ,---,    
  |   |--------->| i |-->| j |-->| k |-->NULL    
  '---'          '---'   '---'   '---'    
    |   
    V   
   NULL

Il va falloir penser à faire des fonctions, sinon ça va être vite le capharnaüm !

-
Edité par rouloude 17 septembre 2020 à 21:38:00

Lea989898

17 septembre 2020 à 21:47:31

Pourriez-vous m'aider s'il vous plait?

rouloude

17 septembre 2020 à 23:32:33

Bon, on ne donne pas des codes tout fait ici. Il faut participer. Je t'ai mis un schéma. Tu ne dit même pas s'il correspond à ton problème !?!

Sais-tu faire des fonctions ? Car il te faut des fonctions pour : créer tes listes, ajouter des éléments à tes listes, afficher tes listes si tu veux en vérifier le bon fonctionnement...

Et aussi, n'oublie pas que scanf attend l'adresse de la variable à modifier !

PierrotLeFou

18 septembre 2020 à 1:45:36

Quelle est l'utilité de la première de ces deux lignes?

t = l->suivA;

t = malloc(sizeof(struct ClisteA));

En plus des conseils de rouloude sur les fonctions, je te suggère d'avoir des noms de variables et de structures plus significatifs.

Autrement, tu vas t'y perdre.

Si tu ne veux pas écrire 'horizontal' au long, essaies 'hor', et 'ver' pour vertical.

Le Tout est souvent plus grand que la somme de ses parties.

Lea989898

18 septembre 2020 à 11:46:42

D’accord merci beaucoup! J’ai essayé avec les fonctions et ça a marché

rouloude

18 septembre 2020 à 12:16:09

Lea989898 a écrit:

D’accord merci beaucoup! J’ai essayé avec les fonctions et ça a marché

Et bien bravo ! Parce que il y avait encore pas mal de boulot à faire !

SofianeMahdad

19 septembre 2020 à 14:55:11

svp la liste verticale j'ai pas trouvé comment la faire?

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct caractere *charListe;

typedef struct caractere

{

char car[2];

charListe suivant;

} caractere;

// ajoute Element en Tete de liste

charListe ajoutEnTete(charListe L, char elem[2])

{

charListe p;

p = malloc(sizeof(caractere )); // allouer un element pour la 1ere valeur

if (p == NULL)

{

printf("EREUR!!! probleme d'allocation memoire \n");

exit(0);

}

strcpy(p->car, elem);

p->suivant = L;

return p;

}

// Ajoute Element apres prcd

charListe ajoutApres(charListe prcd, char elem[2])

{

charListe p;

p = malloc(sizeof(caractere )); // allouer un element pour la 1ere valeur

if (p == NULL)

{

printf("EREUR!!! probleme d'allocation memoire \n");

exit(0);

}

strcpy(p->car,elem);

p->suivant = prcd->suivant;

prcd->suivant = p;

return p;

}

// affiche les elements de la liste

void afficherListe(charListe L)

{

printf("Liste: \n");

while (L != NULL)

{

printf("%4s ", L->car);

L = L->suivant;

}

printf("\n********************************\n\n\n\n");

}

// Cree liste FiFO

charListe creerListFiFo(int N)

{

charListe L, prcd;

int i;

char c[2];

L = NULL;

printf("Donner 1ere Valeur ...\n");

scanf("%s", c);

L = ajoutEnTete(L, c) ; /* ajouter le 1er element d'indice 1 */

prcd = L;

for (i = 2; i <= N; i++)

{

printf("Donner %d eme Valeur ...\n", i);

scanf("%s", c);

prcd = ajoutApres(prcd, c); /* ajouter le i eme element d'indice i */

}

return L;

}

int L1souslisteL2(charListe L1, charListe L2)

{

charListe p1, p2;

int trouve;

trouve = 1;

p1 = L1;

while ((p1 != NULL) && trouve)

{

p2 = L2;

trouve = 0;

while ((p2 != NULL) && !(trouve))

{

if (strstr(p2->car,p1->car))

trouve = 1;

else

p2 = p2->suivant;

}

p1 = p1->suivant;

}

return trouve;

}

void suppression(charListe *liste)

{

if (liste == NULL)

{

exit(EXIT_FAILURE);

}

if (liste->premier != NULL)

{

Element *aSupprimer = liste->suivant;

liste->suivant = liste->suivant->suivant;

free(aSupprimer);

}

int main()

{

charListe tete1, tete2;

int N;

printf("*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/* \n");

printf("/// bienvenue ///");

printf("\n \n cree la liste: 1 \n");

{

printf("Donner le nombre de caracteres N > 0 \n");

scanf("%d", &N);

}while (N <= 0);

tete1 = creerListFiFo(N);

afficherListe(tete1);

printf("\n cree la liste: 2 \n");

{

printf("Donner le nombre de caracteres N > 0 N > 0 \n");

scanf("%d", &N);

}while (N <= 0);

tete2 = creerListFiFo(N);

afficherListe(tete2);

if (L1souslisteL2(tete1, tete2))

printf("***la liste L1 est une sous liste de L2*** \n");

else

printf("***la liste L1 n'est pas une sous liste de L2***\n");

charListe L1;

suppression(tete1);

afficherListe(L1);

printf("\n");

printf("*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*");

return 0;

}

-
Edité par SofianeMahdad 19 septembre 2020 à 14:57:15

rouloude

19 septembre 2020 à 17:10:45

Bonjour !

IMPORTANT : Utilises le bouton code </> du forum pour poster ton code ! (tu peux modifier ton post, lien modifier en haut à droite du post).

SofianeMahdad a écrit:

svp la liste verticale j'ai pas trouvé comment la faire?

C'est comme l'horizontal. D'un point de vue du code horizontal ou vertical, c'est la même chose.

Horizontal ou vertical ce n'est qu'une représentation visuel qui n'a rien à voir avec le code !

PS : En principe quand on a une question, on crée son propre sujet ! On ne pollue pas celui des autres membres du forum !

-
Edité par rouloude 19 septembre 2020 à 17:15:15

PierrotLeFou

19 septembre 2020 à 18:45:31

@rouloude:

Fais-tu un copier-coller de ton message au sujet du bouton code? Tu ferais un bon modérateur.

Dans ces exemples, si je comprend bien, la liste dite "verticale" est la liste primaire.

Elle contient un élément qui est un pointeur ou tête de liste pour chaque liste dite "horizontale".

Au fur et à mesure qu'on crée la liste verticale, il ne faut pas oublier d'initialiser le pointeur vers le premier élément de chaque liste horizontale, s'il y en a un, sinon, c'est le pointeur NULL.

Chacun des deux types de liste comporte dans chaque "noeud" ou élément un pointeur vers l'élément suivant de cette même liste.

Il existe un pointeur vers le premier élément de la liste primaire qu'il ne faut pas oublier d'initialiser.

On peut écrire des fonctions de gestion de ces listes qui seront très semblables, voire identiques dans certains cas.

Par exemple,

+ créer la liste (avec seulement la tête de liste)

+ ajouter un élément, soit au début, au milieu, ou à la fin.

+ éliminer un élément.

+ parcourir la liste

+ afficher la liste si on peut

+ etc...

On peut n'écrire qu'une seule fonction de réservation de mémoire avec malloc.

Je vous joint ce que j'ai déjà écrit, qui me semble utile pour les deux types de liste:

'name' est le nom de la fonction appelante, et 'size' est la quantité de mémoire requise.

// Alouer l'espace pour un nouveau noeud.

void *getNode(char *name, int size) {

void *node;

if((node = malloc(size)) == NULL) {

perror(name);

printf("Dimension: %d\n", size);

exit(2);

}

return(node);

}

PS perror() requière le header errno.h et malloc() et exit() requièrent le header stdlib.h

-
Edité par PierrotLeFou 19 septembre 2020 à 19:03:41

Le Tout est souvent plus grand que la somme de ses parties.