Sujet Précédent Sujet Suivant

Fonction recherche (listes chainées)

cs_adri10 Messages postés 2 Date d'inscription samedi 2 février 2008 Statut Membre Dernière intervention 7 mai 2011 - 6 mai 2011 à 22:55
cs_patatalo Messages postés 1466 Date d'inscription vendredi 2 janvier 2004 Statut Modérateur Dernière intervention 14 février 2014 - 9 mai 2011 à 18:18
Bonjour à tous,

Bon voilà j'ai un gros problème avec ma fonction recherche en liste chainées. Je pensais que mon programme était correct puisqu'en le lançant une première fois, il tournait. Puis j'ai fermé mon programme et réouvert et là...plus rien, du moins pour la fonction recherche. J'ai beau chercher, je ne vois pas comment corriger ma (mes) erreur(s).

Je précise simplement que je ne fais pas de C depuis longtemps et que c'est le tout dernier programme que je ferai pour cette année, et surement le dernier tout court, vu que j'ai ce cours pour la dernière fois.

Autre précision sur le code, je sais que les prototypes de fonctions ne se mettent normalement pas dans une fonction mais mon prof avait fait comme ca pour le début de ce code et j'ai donc continué comme ça.

Merci d'avance!

Voici le code: 

#include<stdio.h>
#include<stdlib.h>

struct liste
{
       int info;
       struct liste *suiv;
};




int main()
{
   int option;
   struct liste * tete;
   int element;
   int menu();
   int creationok=0;
   int compteur;
   struct liste*creation(void);
   struct liste*ajout(struct liste*p,int n);
   struct liste * suppression (struct liste * p,int n);
   void affiche(struct liste*p);
   int comptage (struct liste * p);
   void recherche(struct liste * p,int pointeur);
   do
   {
              option=menu();
              switch(option)
              {
                            /* Création de la liste */
                             case 1 :
                                  if(!creationok)
                             {
                                  
                                  tete=creation();
                                  creationok=1;
                             }
                             break;
                             /* Encodage */
                             case 2 :
                                  if(creationok)
                                  {
                                                 printf("Entrez un element : ");
                                                 scanf("%d",&element);
                                                 tete=ajout(tete,element);
                                  }
                                  else
                                  printf("Creez d'abord une liste\n");
                                  system("pause");
                             break;
                             /* Affichage */
                             case 3 :
                                  if(creationok)
                                  {
                                                 affiche(tete);
                                                 system("pause");
                                  }
                             break;
                             /* Suppression */
                             case 4 :
                                  printf("Entrez un element a supprimer de la liste : ");
                                  scanf("%d",&element);
                                  tete=suppression(tete,element);
                             break;
                             /* Comptage */
                             case 5 :
                                  if(creationok)
                                  printf("il y a %d elements multiples du premier\n",comptage(tete));
                                  system("pause");
                                  break;
                              /* Recherche d'éléments */    
                             case 6 :
                                  printf("Entrez l'element a rechercher");
                                  scanf("%d",&element);
                                  recherche(tete,element);
                                  system("pause");
                                  break;
                                  
                             /* Fermeture */
                             case 0 :
                                  printf("Ce programme va terminer\n\n");
                                  system("pause");
                                  break;
              }
              
   }while(option !=0);
        
}

int menu(void)
{
    int option;
    do
    {
        system("cls");
        printf("0 : Terminer le programme\n");
        printf("1 : Creation d une liste\n");
        printf("2 : Ajout d'un element dans la liste\n");
        printf("3 : Affichage de la liste dans l'ordre croissant\n");
        printf("4 : Suppression d'un element de la liste\n");
        printf("5 : Comptage des elements multiples du premier\n");
        printf("6 : Recherche d'elements\n");
        scanf("%d",&option);
    }while (option>6);
    return option;
}

struct liste*creation(void)
{
       return NULL;
};

/* Ajouter un élément à la liste */

struct liste*ajout (struct liste*p, int n)
{
       struct liste*q;
       if(p!=NULL)
       {
            if(n>p->info)
            {
                            p->suiv=ajout(p->suiv,n);
                            q=p;
            }
            else
            {
                q=(struct liste*)malloc(sizeof(struct liste));
                q->info=n;
                q->suiv=p;
            }
       }
            else
            {
                q=(struct liste*)malloc(sizeof (struct liste));
                q->info=n;
                q->suiv=p;
            }
            return q;
}

/* Affichage des éléments */
void affiche(struct liste*p)
{
     if(p!=NULL)
     {
                printf("\n");
          printf(" %d ",p->info);
          affiche (p->suiv);
          printf("\n");
     }
}
            
/* Suppression d'un élément*/

struct liste * suppression (struct liste * p,int n)
{
       struct liste * q;
       
       if(p!=NULL)
       {
                  if (n>p->info)
                  {
                                p->suiv=suppression(p->suiv,n);
                                q=p;
                  }
                  else
                  if(n==p->info)
                  {
                                q=p->suiv;
                                free(p);
                  }
                  else
                  q=p;
                  return q;
       }
}

/* Comptage des éléments */

int comptage (struct liste * p)
{
    int compteur=0;
    int element=p->info;
    
    
    while (p)
    {
          if((p->info) % (element) == 0)
          compteur++;
          p=p->suiv;
    }
    return compteur;
}

/* Recherche d'un élément */

void recherche(struct liste * p,int pointeur)
{
    pointeur=0;
     while (((pointeur)!=(p->info)) || ((p->suiv) != NULL))
     {
           if ((pointeur)==(p->info))
           {
                                  p=p->suiv;
                                  printf("l'element se trouve en position %d",(pointeur));
           }
           else if((pointeur)>(p->info))
           (pointeur)++;
           else
           printf("Le nombre ne se trouve pas dans la liste mais devrait etre entre la place %d et %d\n",pointeur,(pointeur)+1);
    }
}

3 réponses

Réponse 1 / 3
cs_patatalo Messages postés 1466 Date d'inscription vendredi 2 janvier 2004 Statut Modérateur Dernière intervention 14 février 2014 2
7 mai 2011 à 12:09
salut,

Il y a effectivement pas mal d'erreur et d'omissions. Je ne vais pas réinventer la roue, tu trouveras pas mal de code avec des exemples de listes chainées simples sur internet.

Vite fait:
initialiser la tête de liste à NULL et remplacer créationok par une fonction is_empty().

remplacer le nom de structure liste par noeud.

Si la liste n'est pas crée, la fonction recherche plantera. (fonction a revoir complètement: paramètre pointeur modifié dans la fonction ???)

Souvent, une liste est initialisée avec un noeud par défaut, cela évite pas mal de code de vérification.

Il faut vider la liste avant de quitter.

Ceci est faux:
tete=ajout(tete,element);
Tu mélanges le point d'entrée avec un noeud. Tu devrais avoir deux fonctions si tu ne crée pas un noeud par défaut dans la liste:
liste_push(struct noeud **entry, int info);
liste_ajoute(struct noeud *n, int info);

@++
0
Réponse 2 / 3
cs_adri10 Messages postés 2 Date d'inscription samedi 2 février 2008 Statut Membre Dernière intervention 7 mai 2011
7 mai 2011 à 19:34
Bonjour et merci pour la réponse,

En fait toutes autres fonctions écrites (à part le comptage des nombres et la recherche) ont été écrites par mon prof en classe, donc en principe je n'ai pas besoin d'autres fonctions. La consigne qui nous avait été donnée était de faire ce code sans élément sentinelle.

Bref, il n'y a que la fonction recherche qui me pose problème en réalité.
0
Réponse 3 / 3
cs_patatalo Messages postés 1466 Date d'inscription vendredi 2 janvier 2004 Statut Modérateur Dernière intervention 14 février 2014 2
9 mai 2011 à 18:18
re,

Je ne sais pas si ton prof se rend bien compte du gaspillage de mémoire qu'il pourrait obtenir en gerant une liste par récursivité. 

void recherche(struct noeud *p, int n)
{
    struct noeud *c = p;
    
    while (c != NULL && (n < (c->info)))
        c = c->suiv;

    if (c !NULL && n c->info)
        printf("l'element se trouve en position %d", n);
}


@++
0

Discussions similaires

Barre de recherche web
martial30061999 -
HitTshite19 -

1 réponse
ISBN recherche web
cs_etniqs -
digger23 -

2 réponses
recherche dans base mysql
karlito911 -
kohntark -

119 réponses
Barre de recherche
m@rginale -
jordane45 -

1 réponse
remise a zero de fonction
cs_galian -
ADPro22 -

6 réponses
Rejoignez-nous