fonction recherche dans une liste chainée

**hanafi_hamza** · 19/10/2014, 12h06

Bonjour à tous

Je fais une fonction recherche qui permet de chercher un élément dans une liste doublement chaînée
voila:

Code:

Cellule *chercher_chaine_double(int code, Cellule *ll)
{
	if(ll==NULL)
	{
		return NULL;
	}
	else
	{
		while(ll!=NULL)
		{
			if(ll->e.code==code)
		    {
			   return ll;
		    }
		    else
		    {
			   ll=ll->suiv;
		    }
		}
	}
}

Dans le main(): lorsque je fais cette affectation le programme se bloque !!

Code:

cellule *f;
f=chercher(code,malistechainee);

Merci de m'aider

**Chanur** · 19/10/2014, 14h52

Bonjour,

Il faudrait nous montrer comment tu déclares et comment tu initialises ta liste chaînée.

**hanafi_hamza** · 19/10/2014, 16h09

voila comment je fais:

Code:

	cellule *l=NULL;

**Chanur** · 19/10/2014, 16h36

Sérieusement, comment elle est initialisée ?
Parce que si c'est juste un pointeur nul, la fonction chercher_chaine_double retourne NULL. C'est testé à la première ligne.

A voir en vidéo sur Futura · Aujourd'hui

**hanafi_hamza** · 19/10/2014, 16h46

Mais non ma fonction rertourne

Code:

return ll;

enfaîte j'ai un tableau qui contient des données des étudiants et j'ai une fonction qui transforme les données du tableau vers une liste

Code:

int Creer_liste_doublement_chainee(Etudiant Et[], int n,Cellule **ll)
{
	Cellule *p,*q;
	int i;
	*ll=NULL;
	for(i=0;i<n;i++)
	{
		p=(Cellule*)malloc(sizeof(Cellule));
		p->e.code=Et[i].code;
		p->e.nom=(char*)malloc(sizeof(char)*20);
		strcpy(p->e.nom,Et[i].nom);
	    p->e.moy=Et[i].moy;
		p->suiv=NULL;
		p->prec=NULL;
		if(*ll==NULL)
		{
			*ll=p;
			q=p;
		}
		else
		{
			q->suiv=p;
			p->prec=q;
			q=p;
		}
	}
	return n;
}

**Chanur** · 19/10/2014, 17h09

Pour l'instant je ne vois pas de problème, mais il manque la définition de Cellule, de Etudiant et de la fonction qui appelle Creer_liste_doublement_chainee () et chercher_chaine_double().

Ce serait nettement plus simple de tout donner : on pourrait faire des tests, plutôt que d'être réduit à lire le code, ce qui n'a jamais été suffisant pour trouver un bug ...

**hanafi_hamza** · 19/10/2014, 17h42

bon je suis tres fainéant !!

voila tout le code
c'est un travail que je dois rendre ce lundi

Code:

#include<string.h>
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
typedef struct{
    int code;
    char *nom;
    float moy;
              }Etudiant;
//liste simplement chainée
typedef struct cellule cellule;
struct cellule{
	Etudiant e;
	cellule *suiv;
};
//liste doublement chainée
typedef struct Cellule Cellule;
struct Cellule{
	Etudiant e;
	Cellule *suiv;
	Cellule *prec;
};
//----------------------------------------------------------------Liste simplement chainée (LS) -----------------------------------------------------------  
int creer_liste_simple(Etudiant Et[], int n, cellule **l)
{
	int i;
	*l=NULL;
	cellule *p,*q;
	for(i=0;i<n;i++)
	{
		p=(cellule*)malloc(sizeof(cellule));
		p->e.code=Et[i].code;
		p->e.nom=(char*)malloc(sizeof(char));
	    strcpy(p->e.nom,Et[i].nom);
		p->e.moy=Et[i].moy;
		p->suiv=NULL;
		if(*l==NULL)
		{
			*l=p;
			q=p;
		}
		else
		{
			q->suiv=p;
			q=p;
		}
	}
return n;
}
// afficher la chaine simple
void Afficher_Chaine_simple(cellule *l)
{
	if(l==NULL)
	{
		printf("aucun element n'existe dans la chaine !!\n");
	}
	else
	{
		while(l!=NULL)
		{
			printf("le code de l'eudiant: %d\n",l->e.code);
			printf("le nom de l'eudiant: %s\n",l->e.nom);
	    	printf("la moyenne de l'eudiant: %f\n",l->e.moy);
	    	printf("\n");
	    	l=l->suiv;
		}
	}
}
// ajouter un etudiant au debut de la liste simplement chaine 
void ajouter_debut_chaine_simple(Etudiant Et,cellule **l)
{
	cellule *N;
	N=(cellule*)malloc(sizeof(cellule));
	N->e.code=Et.code;
	N->e.nom=(char*)malloc(sizeof(char));
	strcpy(N->e.nom,Et.nom);
    N->e.moy=Et.moy;
	N->suiv=NULL;
	if(*l==NULL)
	{
		*l=N;
	}
	else
	{
		N->suiv=*l;
		*l=N;
	}
}
// la recherche dans LS
cellule *chercher_chaine_simple(int code, cellule *l)
{
	if(l==NULL)
	{
		return NULL;
	}
	else
	{
		while(l!=NULL)
		{
			if(l->e.code==code)
			{
				return l;
			}
			else 
			{
				l=l->suiv;
			}
		}
	}
}
// affiche recherche 
void affiche_recherche_simple(cellule *p)
{
	if(p!=NULL)
	{
		printf("voici l'etudiant que vous cherchez\n");
	    printf("le code de l'eudiant: %d\n",p->e.code);
	    printf("le nom de l'eudiant: %s\n",p->e.nom);
	    printf("la moyenne de l'eudiant: %f\n",p->e.moy);
	}
	else
	{
		printf("ce code n'existe pas\n");
	}		
}     
// ajouter avant etudiant LS
void ajouter_avant_LS(Etudiant e, int code, cellule **l)
{
	cellule *N,*r,*q,*p;
	r=chercher_chaine_simple(code,*l);
	N=(cellule*)malloc(sizeof(cellule));
	N->e.code=e.code;
	N->e.moy=e.moy;
	N->e.nom=(char*)malloc(sizeof(char));
	strcpy(N->e.nom,e.nom);
	N->suiv=NULL;
	if(*l==NULL)
	    {
	    	*l=N;
	    }
	    else
	    {
	        q=*l;
	        p=*l;
	        if(r==*l)
	        {
	        	N->suiv=r;
	    	    *l=N;
	        }
	        else
	        {
	    	   while(p!=r)
	    	   {
	    	   	  q=p;
	    		  p=p->suiv;
	    	   }
	    	N->suiv=r;
	    	q->suiv=N;
	        }
	    }
}
//ajouter apres etudiant
void ajouter_apres_LS(Etudiant e, int code, cellule **l)
{
	cellule *N,*r;
	r=chercher_chaine_simple(code,*l);
	if(r!=NULL)
	{
		
	    N=(cellule*)malloc(sizeof(cellule));
	    N->e.code=e.code;
	    N->e.moy=e.moy;
	    N->e.nom=(char*)malloc(sizeof(char));
	    strcpy(N->e.nom,e.nom);
	    N->suiv=NULL;
		if(*l==NULL)
	    {
	    	*l=N;
	    }
	    else
	    {
	    	
	        N->suiv=r->suiv;
	     	r->suiv=N;
	    }
   }
}
//ajouter un etudiant à la fin
void ajouter_fin_LS(Etudiant Et, cellule **l)
{ 
	cellule *p,*N;
	N=(cellule*)malloc(sizeof(cellule));
	N->e.code=Et.code;
	N->e.nom=(char*)malloc(sizeof(char));
	strcpy(N->e.nom,Et.nom);
	N->e.moy=Et.moy;
	N->suiv=NULL;
	p=*l;
	if(*l==NULL)
	   {
		*l=N;
	   }
	   else
	   {
	   	   while(p->suiv!=NULL)
	     {
		    p=p->suiv;
	     }  
	  	    p->suiv=N;
	   }
}
//Supprimer dans LS
void supprimer_etudiant_LS(cellule **l, int code)
{
		cellule *r,*q,*p;
	p=*l;
	q=*l;
	r=chercher_chaine_simple(code,*l);
	if(r!=NULL)
	{
		if(*l==r)
	    {
	    	*l=r->suiv;
	    }
	    else
	    {
	    	while(p!=r)
		    {
		    	q=p;
		    	p=p->suiv;
		    }
		    q->suiv=r->suiv;
		    free(r);
	    }
	    if(r->suiv==NULL)
	    {
	    	free(r);
	    }
	    printf("supprimer avec succes\n");
	}
	else
	{
		printf("ce code n'existe pas\n");
	}
}
// permutation du tri de la chaine simplement chainees
void permuter_cellule(cellule *a,cellule *b)
{
	cellule *Aide;
	Aide=(cellule*)malloc(sizeof(cellule));
	Aide->e.code=a->e.code;
	Aide->e.moy=a->e.moy;
	Aide->e.nom=(char*)malloc(sizeof(char));
	strcpy(Aide->e.nom,a->e.nom);
	
	a->e.code=b->e.code;
	a->e.moy=b->e.moy;
	strcpy(a->e.nom,b->e.nom);
	
	b->e.code=Aide->e.code;
	b->e.moy=Aide->e.moy;
	strcpy(b->e.nom,Aide->e.nom);
}
// tri de LS
void tri_chaine_LS(cellule *l)
{
	cellule *p;
	p=l;
	bool FIN=true;
	while(FIN!=false)
	{	  
		  FIN=false;
		  while(l->suiv!=NULL)
		  {
			if(strcmp(l->e.nom,l->suiv->e.nom)>0)
			{    
				permuter_cellule(l,l->suiv);
				FIN=true;
			}
			l=l->suiv;
		  }
		  l=p;
	}
}
//----------------------------------------------------------------Liste doublement chainée (LD)-----------------------------------------------------------     
//copier les élément du tableau dans la liste doublement chainée
 int Creer_liste_doublement_chainee(Etudiant Et[], int n,Cellule **ll)
{
	Cellule *p,*q;
	int i;
	*ll=NULL;
	for(i=0;i<n;i++)
	{
		p=(Cellule*)malloc(sizeof(Cellule));
		p->e.code=Et[i].code;
		p->e.nom=(char*)malloc(sizeof(char)*20);
		strcpy(p->e.nom,Et[i].nom);
	    p->e.moy=Et[i].moy;
		p->suiv=NULL;
		p->prec=NULL;
		if(*ll==NULL)
		{
			*ll=p;
			q=p;
		}
		else
		{
			q->suiv=p;
			p->prec=q;
			q=p;
		}
	}
	return n;
}
// afiicher la liste doublement chainée
void Afficher_Chaine_double(Cellule *ll)
{
	if(ll==NULL)
	{
		printf("aucun element n'existe dans la chaine !!\n");
	}
	else
	{
		while(ll!=NULL)
		{
			printf("Code de l'eudiant: %d\n",ll->e.code);
			printf("le nom de l'eudiant: %s\n",ll->e.nom);
	    	printf("la moyenne de l'eudiant: %f\n",ll->e.moy);
	    	printf("\n");
	    	ll=ll->suiv;
		}
	}
}
//chercher un etudiant dans la liste doublement chainée
Cellule *chercher_chaine_double(int code, Cellule *ll)
{
	if(ll==NULL)
	{
		return NULL;
	}
	else
	{
		while(ll!=NULL)
		{
			if(ll->e.code==code)
		    {
			   return ll;
		    }
		    else
		    {
			   ll=ll->suiv;
		    }
		}
	}
}
// afficher la recherche 
void affiche_recherche_double(Cellule *p)
{
	if(p!=NULL)
	{
		printf("voici l'etudiant que vous cherchez\n");
	    printf("le code de l'eudiant: %d\n",p->e.code);
	    printf("le nom de l'eudiant: %s\n",p->e.nom);
	    printf("la moyenne de l'eudiant: %f\n",p->e.moy);
	}
	else
	{
		printf("ce code n'existe pas\n");
	}	
}
// ajouter un etudiant au debut de la liste doublement chainée
void ajouter_debut_LD(Etudiant Et, Cellule **ll)
{
	Cellule *N;
	N=(Cellule*)malloc(sizeof(Cellule));
	N->e.code=Et.code;
	N->e.nom=(char*)malloc(sizeof(char));
	strcpy(N->e.nom,Et.nom);
	N->e.moy=Et.moy;
	N->suiv=NULL;
	N->prec=NULL;
	if(*ll==NULL)
	{
		*ll=N;
	}
	else
	{
		N->suiv=*ll;
		(*ll)->prec=N;
		*ll=N;
	}
}

}

**hanafi_hamza** · 19/10/2014, 17h43

le reste !!

Code:

//ajouter avant un etudiant 
void ajouter_avant_LD(Etudiant Et,int code,Cellule **ll)
{
	Cellule *N,*r;
	N=(Cellule*)malloc(sizeof(Cellule));
	N->e.code=Et.code;
	N->e.moy=Et.moy;
	N->e.nom=(char*)malloc(sizeof(char));
	strcpy(N->e.nom,Et.nom);
	N->suiv=NULL;
	N->prec=NULL;
	r=chercher_chaine_double(code,*ll);
	if(*ll==NULL)
	{
		*ll=N;
	}
	if(r!=*ll) 
	{
		N->prec=r->prec;
		r->prec->suiv=N;
		N->suiv=r;
		r->prec=N;
	}
	else
	{
		N->suiv=r;
		r->prec=N;
		*ll=N;
	}
}
//ajouter après un etudiant
void ajouter_apres_LD(Etudiant Et,int code,Cellule **ll)
{
    Cellule *N,*r;
	N=(Cellule*)malloc(sizeof(Cellule));
	N->e.code=Et.code;
	N->e.moy=Et.moy;
	N->e.nom=(char*)malloc(sizeof(char));
	strcpy(N->e.nom,Et.nom);
	N->suiv=NULL;
	N->prec=NULL;
	r=chercher_chaine_double(code,*ll);
	if(r!=NULL)
	{
		if(r->suiv==NULL)
		{
			r->suiv=N;
			N->prec=r;
		}
		else
		{ 
			N->suiv=r->suiv;
			r->suiv->prec=N;
			N->prec=r;
			r->suiv=N;
		}
	}
}
//ajouter un etudiant dans la fin de la liste doublement chainée
void ajouter_fin_chaine_double(Etudiant Et, Cellule **ll)
{
	Cellule *N;
	N=(Cellule*)malloc(sizeof(Cellule));
	N->e.code=Et.code;
	N->e.nom=(char*)malloc(sizeof(char));
	strcpy(N->e.nom,Et.nom);
	N->e.moy=Et.moy;
	N->suiv=NULL;
	N->prec=NULL;
	Cellule *p;
	p=*ll;
	if(*ll==NULL)
	{
		*ll=N;
	}
	else
	{
		while(p->suiv!=NULL)
		{
			p=p->suiv;
		}
		p->suiv=N;
		N->prec=p;
	}
}
//supprimer un etudiant dans la liste doublement chainée
void supprimer_etudiant_LD(int code, Cellule **l)
{
	Cellule *r;
	r=chercher_chaine_double(code,*l);
	if(r!=NULL)
	{
	   if(r==*l)
	   {
		 *l=r->suiv;
		 free(r);
	   }
	   else if(r->suiv==NULL)
	   {
		free(r);
		r->prec->suiv=NULL;
	   }
	   else
	   {
		 r->prec->suiv=r->suiv;
		 r->suiv->prec=r->prec;
		 free(r);
	   }
	}
	else
	{
		printf("ce code n'existe pas !!\n");
	}
}
// permutation du tri de la chaine doublement chainees
void permuter_Cellule(Cellule *a,Cellule *b)
{
	Cellule *Aide;
	Aide=(Cellule*)malloc(sizeof(Cellule));
	Aide->e.code=a->e.code;
	Aide->e.moy=a->e.moy;
	Aide->e.nom=(char*)malloc(sizeof(char));
	strcpy(Aide->e.nom,a->e.nom);
	
	a->e.code=b->e.code;
	a->e.moy=b->e.moy;
	strcpy(a->e.nom,b->e.nom);
	
	b->e.code=Aide->e.code;
	b->e.moy=Aide->e.moy;
	strcpy(b->e.nom,Aide->e.nom);
}
// tri de LD
void tri_chaine_LD(Cellule *l)
{
	int i;
	Cellule *p;
	p=l;
	bool FIN=true;
	while(FIN!=false)
	{	  
		  FIN=false;
		  while(l->suiv!=NULL)
		  {
			if(strcmp(l->e.nom,l->suiv->e.nom)>0)
			{
				permuter_Cellule(l,l->suiv);
				FIN=true;
			}
			l=l->suiv;
		  }
		  l=p;
	}
}
//----------------------------------------------------------------tableau des étudiants-----------------------------------------------------------
// fonction lecture
void Lecture(Etudiant Et[] , int *n)
{
	int i;
	printf("donner le nombre des etudiants: ");
	scanf("%d",n);		
	for(i=0;i<(*n);i++)
	{	
		printf("entrer le nom de l'etudiant: ");
 	    Et[i].nom=(char*)malloc(sizeof(char)*20);
        scanf("%s",Et[i].nom);
		printf("entrer le code de l'etudiant: ");
	    scanf("%d",&Et[i].code);
	    printf("entrer la moyenne de l'etudiant: ");
 	    scanf("%f",&Et[i].moy);
	}
}
// fonction qui affiche le tableau
void Afficher(Etudiant Et[], int n) 
{
	int i;	      	   
	for(i=0;i<n;i++)
	{
   	 printf("le code de l'etudiant : %d\n",Et[i].code);
	 printf("le nom de l'etudiant : %s\n",Et[i].nom);
	 printf("la moyenne de l'etudiant : %f\n \n",Et[i].moy);
	}
}
// fonction permet d'afficher un seul etudiant sachant sa position
void Afficher1(Etudiant Et[], int i)
{
	printf("le code de l'etudiant : %d\n",Et[i].code);
	printf("le nom de l'etudiant : %s\n",Et[i].nom);
	printf("la moyenne de l'etudiant : %f\n \n",Et[i].moy);
}
//fonction max
int max(Etudiant Et[], int n)
{
	int i,pos_max;
	pos_max=0;
	for(i=0;i<n;i++)
	{
		if((Et[i].moy)>(Et[pos_max].moy))
		{
		    pos_max=i;
		}
	}
return pos_max;
}
//fonction min
int min(Etudiant Et[], int n)
{
	int i,pos_min;
	pos_min=0;
	for(i=0;i<n;i++)
	{
		if((Et[i+1].moy)<(Et[pos_min].moy))
		{
		    pos_min=i+1;
		}
	}
return pos_min;
}
//fonction d'occurrence
int occurrence(Etudiant Et[],int n, float val)
{
	int i,nbr;
	for(i=0;i<n;i++)
	{
		if(Et[i].moy==val)
		{
			nbr++;
		}
	}
	return nbr;
}
// fonction d'echange
void echanger(Etudiant Et[],int i, int j)
{
	Etudiant aux;
	aux.code=Et[i].code;
	aux.nom=(char*)malloc(sizeof(char)*strlen(Et[i].nom)+1);
	strcpy(aux.nom,Et[i].nom);
	aux.moy=Et[i].moy;
	Et[i].code=Et[j].code;
	Et[i].nom=(char*)malloc(sizeof(char)*strlen(Et[j].nom)+1);
	strcpy(Et[i].nom,Et[j].nom);
	Et[i].moy=Et[j].moy;
	Et[j].code=aux.code;
	strcpy(Et[j].nom,aux.nom);
	Et[j].moy=aux.moy;
}
// fonction permuter un par un
void permuter_1(Etudiant Et[],int n)
{
	int i;
	for (i=0;i<n-1;i=i+2)
	{
		echanger(Et,i,i+1);
	}
}
// fonction permuter (inverser)
void permuter_2(Etudiant Et[], int n)
{
	int i;
	Etudiant aide;
	for(i=0;i<(n/2);i++)
	{
		aide.code=Et[i].code;
		aide.nom=Et[i].nom;
		aide.moy=Et[i].moy;
		Et[i].code=Et[n-1-i].code;
		Et[i].nom=Et[n-1-i].nom;
		Et[i].moy=Et[n-1-i].moy;
		Et[n-1-i].code=aide.code;
		Et[n-1-i].nom=aide.nom;
		Et[n-1-i].moy=aide.moy;
	}	
}
// fonction inserer
void inserer(Etudiant Et[],int *n, int p, Etudiant var)
{
	Etudiant aux;
 	 printf("dans quelle position vous voullez l'inserer ? ");
	 scanf("%d",&p);
	if(p>=0 && p<=(*n))
	{
  	    (*n)++;
 	    Et[*n-1].code=Et[p].code;
		Et[*n-1].nom=Et[p].nom;
		Et[*n-1].moy=Et[p].moy;
		Et[p].code=var.code;
		Et[p].nom=var.nom;
		Et[p].moy=var.moy;		
	}
}
//fonction qui retourne la position d'étudiant qu'on cherche
int recherche_pos(Etudiant Et[], int n, int C)
{
	int i;
	for(i=0;i<n;i++)
	{
		if(Et[i].code==C)
		{
		return i;	
		}		
	}
	return -1;
}
//supprimer un etudiant 
void supprimer(Etudiant Et[], int *n, int pos)
{
	int i;
	for(i=pos;i<(*n);i++)
	{
		Et[i].code=Et[i+1].code;
		Et[i].nom=Et[i+1].nom;
		Et[i].moy=Et[i+1].moy;
	}
	(*n)--;
}
// les Tris :)
// tri à bulle
void tri_a_bulle(Etudiant Et[], int n)
{
	bool Bool=true;
	int i;
	while(Bool)
	{	  
		  Bool=false;
		  for(i=0;i<n-1;i++)
		  {
			if(Et[i].moy>Et[i+1].moy)
			{
				echanger(Et,i,i+1);
				Bool=true;
			}
		  }	
	}	
}
// tri par insertion
void tri_par_insertion(Etudiant Et[], int n)
{
	int i,cpt;
	float memo0;
	int memo1;
	char *memo2;
	for(i=0;i<n;i++)
	{
		memo0=Et[i].moy;
		memo1=Et[i].code;
		memo2=(char*)malloc(sizeof(char)*strlen(Et[i].nom));
		strcpy(memo2,Et[i].nom);
		memo2=Et[i].nom;
		cpt=i;
		while(cpt>0 && Et[cpt-1].moy>memo0)
		{
			Et[cpt].moy=Et[cpt-1].moy;
			Et[cpt].code=Et[cpt-1].code;
			Et[cpt].nom=(char*)malloc(sizeof(char)*strlen(Et[cpt-1].nom));
			strcpy(Et[cpt].nom,Et[cpt-1].nom);
			cpt--;
		}
		Et[cpt].moy=memo0;
		Et[cpt].code=memo1;
		Et[cpt].nom=memo2;
	}
}
// tri par fusion
void fusion(Etudiant T[],int d1,int f1,int f2)
{
    Etudiant *tab1;
    int d2=f1+1;
    int cpt1=d1;
    int cpt2=d2;
    int i;    
    tab1=(Etudiant*)malloc((f1-d1+1)*sizeof(Etudiant)*20);
    for(i=d1;i<=f1;i++)
    {
    	tab1[i-d1]=T[i];
    }
    for(i=d1;i<=f2;i++)
    {
    	if (cpt1==d2) 
        {
        	break; 
        }
        else if (cpt2==(f2+1))
        {
        	T[i]=tab1[cpt1-d1];
            cpt1++;
        }
        else if (tab1[cpt1-d1].moy<T[cpt2].moy)
        {
        	T[i]=tab1[cpt1-d1]; 
            cpt1++;
        }
        else
        {
        	T[i]=T[cpt2];
            cpt2++;
        }
   }
   free(tab1);
}

**hanafi_hamza** · 19/10/2014, 17h45

Encore

Code:

void tri_fusion0(Etudiant T[],int d,int f)
{
	if (d!=f)
	{
		int m;
        m=(f+d)/2;
        tri_fusion0(T,d,m);
        tri_fusion0(T,m+1,f);
        fusion(T,d,m,f);
    }
}
void tri_fusion(Etudiant T[],int l)
{
    if (l>0)
    {
            tri_fusion0(T,0,l-1);
    }
}
// tri rapide
int partition( Etudiant *T, int d, int f)
    {
	     int cpt=d;
		 Etudiant pivot=T[d];
		 int i;
         for(i=d+1;i<=f;i++)
		 { 
            if(T[i].moy<pivot.moy)
			{
			    cpt++;
				echanger(T,cpt,i);
			}
		}
		echanger(T,cpt,d); 
       return(cpt);
	}
	
void tri_rapide0( Etudiant *T, int d, int f)
    {
	  if (d<f)
	   { 
	      int pivot=partition(T,d,f);
		  tri_rapide0(T,d,pivot-1);
		  tri_rapide0(T,pivot+1,f);
	   }
	}
	
void tri_rapide( Etudiant *T, int n)
{
   tri_rapide0(T,0,n-1);
}
// tri par selection
void tri_par_selection(Etudiant Et[], int n)
{
	int i,j,maxp=0;
	for(i=0;i<n-1;i++)
	{
		maxp=i;
		for(j=i+1;j<n;j++)
		{
			if(Et[j].moy<Et[maxp].moy)
			{
				maxp=j;
			}
		}
		echanger(Et,i,maxp);
	}
}
//Le Main :
main()
{
	Etudiant *Et;
	int n,i;
	Et=(Etudiant*)malloc((sizeof(Etudiant)*n));
	cellule *l=NULL;
	Cellule *ll=NULL;
    int choix=1000; //je donne n'importe quelle valeur 
    while(choix!=34)
	{
		printf(" ________________________________Menu Principal______________________________\n");
		printf("|                                                                            |\n");		
		printf("|   01-Lecture (tableau)                                                     |\n");
		printf("|                                                                            |\n");	
		printf("|                          liste simplement chainee                          |\n");
		printf("|                                                                            |\n");					
		printf("|   02-transferer vers une liste simplement chainee                          |\n");
		printf("|   03-afficher la liste simplement chainee                                  |\n");
		printf("|   04-ajouter un etudiant au debut de la liste simplement chainee           |\n");
		printf("|   05-ajouter avant un etudiant dans liste simplement chainee               |\n");
		printf("|   06-ajouter apres un etudiant dans  liste simplement chainee              |\n");	
		printf("|   07-ajouter un etudiant a la fin de  liste simplement chainee             |\n");
		printf("|   08-supprimer un etudiant dans liste simplement chainee                   |\n");
		printf("|   09-trier la liste simplement chainees                                    |\n");
		printf("|   10-recherche dans la liste simplement chainee                            |\n");
		printf("|                                                                            |\n");	
		printf("|                                                                            |\n");	
		printf("|                           liste doublement chainees                        |\n");
		printf("|                                                                            |\n");	
		printf("|   11-transferer vers une liste doublement chainee                          |\n");		
		printf("|   12-affiche la liste doublement                                           |\n");
		printf("|   13-ajouter un etudiant au debut de la liste doublement chainee           |\n");
		printf("|   14-ajouter avant un etudiant dans la liste doublement chainee            |\n");
		printf("|   15-ajouter apres un etudiant dans la liste doublement chainee            |\n");
		printf("|   16-ajouter un etudiant a la fin de la liste doublement chainee           |\n");
		printf("|   17-supprimer un etudiant dans la liste doublement chainee                |\n");		
		printf("|   18-trier la liste doublement chainees                                    |\n");
		printf("|   19-recherche dans la liste doublement chainee                            |\n");
		printf("|                                                                            |\n");
		printf("|                                                                            |\n");	
		printf("|                                   Tableau                                  |\n");
		printf("|                                                                            |\n");																	
		printf("|   20-afficher l'ensemble des etudiants dans un tableau                     |\n");
		printf("|   21-le moyenne max                                                        |\n");
		printf("|   22-le moyenne min                                                        |\n");
		printf("|   23-occurence d'une moyenne                                               |\n");
		printf("|   24-inserer un etudiant                                                   |\n");
		printf("|   25-permuter un par un                                                    |\n");
		printf("|   26-permuter (inverser)                                                   |\n");
        printf("|   27-Recherche un etudiant                                                 |\n");
	    printf("|   28-supprimer un etudiant                                                 |\n");
        printf("|   29-trier par methode de tri a bulle                                      |\n");
        printf("|   30-trier par methode de tri par insertion                                |\n");
        printf("|   31-trier par methode de tri fusion                                       |\n");
        printf("|   32-trier par methode de tri rapide                                       |\n");	
        printf("|   33-trier par methode de tri par selection                                |\n");								
		printf("|   34-Sortir                                                                |\n");
		printf("|____________________________________________________________________________|\n");
        printf("entrer votre choix: ");
        scanf("%d",&choix);
        printf("\n");
        switch(choix)
        {
        	 case 01:
		            {
		             Lecture(Et,&n);
    		         break;
     	            }
        	 case 02:
			     {
			     	creer_liste_simple(Et,n,&l);
			     	printf("liste creer avec succes\n");
			     	break;
			     }	
			 case 03:
			     {
			     	Afficher_Chaine_simple(l);
			     	break;
			     }
			 case 04:
			     {
			     	Etudiant Et;
			     	printf("donner le code de l'etudiant a ajouter");
			     	scanf("%d",&Et.code);
			     	printf("donner le nom de l'etudiant a ajouter");
			     	Et.nom=(char*)malloc(sizeof(char));
			     	scanf("%s",Et.nom);	     	
			     	printf("donner la moyenne de l'etudiant a ajouter");
			     	scanf("%f",&Et.moy);
			     	ajouter_debut_chaine_simple(Et,&l);
			     	break;
			     }    
			 case 05:
			     {
			     	Etudiant Et;
			     	int code;
			     	printf("donner le code de l'etudiant a ajouter");
			     	scanf("%d",&Et.code);
			     	printf("donner le nom de l'etudiant a ajouter");
			     	Et.nom=(char*)malloc(sizeof(char));
			     	scanf("%s",Et.nom);	     	
			     	printf("donner la moyenne de l'etudiant a ajouter");
			     	scanf("%f",&Et.moy);
			     	printf("donner le code de l'etudiant que vous voulez inserer avant lui: ");
			     	scanf("%d",&code);
			     	ajouter_avant_LS(Et,code,&l);
			     	break;
			     }
			case 06:
			  	{
			  		
			      	Etudiant Et;
			        int code;
			        printf("donner le code de l'etudiant a ajouter");
		     	    scanf("%d",&Et.code);
		     	    printf("donner le nom de l'etudiant a ajouter");
		     	    Et.nom=(char*)malloc(sizeof(char));
					scanf("%s",Et.nom);	     	
			     	printf("donner la moyenne de l'etudiant a ajouter");
			       	scanf("%f",&Et.moy);
			        printf("donner le code de l'etudiant que vous voulez inserer apres lui: ");
			        scanf("%d",&code);
			  	    ajouter_apres_LS(Et,code,&l);
			  	    	break;
			  	}
			  case 07:
			  	 {
			  	 	
			  	    Etudiant Et;
			  	    printf("donner le code de l'etudiant a ajouter");
			     	scanf("%d",&Et.code);
			     	printf("donner le nom de l'etudiant a ajouter");
			     	Et.nom=(char*)malloc(sizeof(char));
			     	scanf("%s",Et.nom);	     	
			     	printf("donner la moyenne de l'etudiant a ajouter");
			        scanf("%f",&Et.moy);
			  	    ajouter_fin_LS(Et,&l);
			  	    break;
			      }

**hanafi_hamza** · 19/10/2014, 17h46

En fin ..

Code:

			  case 8:
			  	    {
			  	    	int code;
			  	    	printf("donner le code de l'etudiant a supprimer: ");
			     	    scanf("%d",&code);
			  	    	supprimer_etudiant_LS(&l,code);
			  	    	break;
			  	    }
			  	case 9:
			  	    {
			  	    	tri_chaine_LS(l);
			  	    	printf("tri effectuer avec succes\n");
			  	    	break;
			  	    }	
			   case 10:
			  	    {
			  	    	
			    	    int code;                                                                 
			    	    printf("entrer le code de l'etudiant a chercher: ");
			    	    scanf("%d",&code);
                                    Cellule *f;
                                     f=(cellule*)malloc(sizeof(cellule));
                                     f->e.nom=(char*)malloc(sizeof(char));
                                     f=chercher_chaine_simple(code,l);      
			    	    {
	    	                    affiche_recherche_simple(f);
			    	    }
			    	    break;
			  	    }
			   case 11:
			  	    {
			  	    	Creer_liste_doublement_chainee(Et,n,&ll);
			  	    	printf("liste creer avec succes\n");
			     	    break;
			  	    }
			   case 12:
			        {
			        	Afficher_Chaine_double(ll);
			        	break;
			        }
			   case 13:
			        {
			        	
			     	    Etudiant Et;
			     	    printf("donner le code de l'etudiant a ajouter");
			     	    scanf("%d",&Et.code);
			      	    printf("donner le nom de l'etudiant a ajouter");
			     	    Et.nom=(char*)malloc(sizeof(char));
			     	    scanf("%s",Et.nom);	     	
			     	    printf("donner la moyenne de l'etudiant a ajouter");
			     	    scanf("%f",&Et.moy);
			     	    ajouter_debut_LD(Et,&ll);
			     	    break;
			        }			     
			case 14:
			     {
			     	Etudiant Et;
			     	int code;
			     	printf("donner le code de l'etudiant a ajouter");
			     	scanf("%d",&Et.code);
			     	printf("donner le nom de l'etudiant a ajouter");
			     	Et.nom=(char*)malloc(sizeof(char));
			     	scanf("%s",Et.nom);	     	
			     	printf("donner la moyenne de l'etudiant a ajouter");
			     	scanf("%f",&Et.moy);
			     	printf("donner le code de l'etudiant que vous voulez inserer avant lui: ");
			     	scanf("%d",&code);
			     	ajouter_avant_LD(Et,code,&ll);
			     	break;
			     }			     
			 case 15:
			     {
			     	Etudiant Et;
			     	int code;
			     	printf("donner le code de l'etudiant a ajouter");
			     	scanf("%d",&Et.code);
			     	printf("donner le nom de l'etudiant a ajouter");
			     	Et.nom=(char*)malloc(sizeof(char));
			     	scanf("%s",Et.nom);	     	
			     	printf("donner la moyenne de l'etudiant a ajouter");
			     	scanf("%f",&Et.moy);
			     	printf("donner le code de l'etudiant que vous voulez inserer avant lui: ");
			     	scanf("%d",&code);
			     	ajouter_apres_LD(Et,code,&ll);
			     	break;
			     }			     
			 case 16:
		   	     {
		   	     	
			  	    Etudiant Et;
			  	    printf("donner le code de l'etudiant a ajouter");
			     	scanf("%d",&Et.code);
			     	printf("donner le nom de l'etudiant a ajouter");
			     	Et.nom=(char*)malloc(sizeof(char));
			     	scanf("%s",Et.nom);	     	
			     	printf("donner la moyenne de l'etudiant a ajouter");
			        scanf("%f",&Et.moy);
			  	    ajouter_fin_chaine_double(Et,&ll);
			  	    break;
			  	 }			     
			 case 17:
			  	    {
			  	    	int code;
			  	    	printf("donner le code de l'etudiant a supprimer: ");
			     	    scanf("%d",&code);
			  	    	supprimer_etudiant_LD(code,&ll);
			  	    	break;
			  	    }
			 	case 18:
			  	    {
			  	    	tri_chaine_LD(ll);
			  	    	printf("tri effectue avec succes\n");
			  	    	break;
			  	    }
			   case 19:
			  	    {
			  	    	int code;                                                                
			    	    printf("entrer le code de l'etudiant a chercher: ");
			    	    scanf("%d",&code);
                                    Cellule *f;
                                     f=(Cellule*)malloc(sizeof(Cellule));
                                     f->e.nom=(char*)malloc(sizeof(char));
                                     f=chercher_chaine_simple(code,l);   
			    	    {
	    	                    affiche_recherche_double(f);
			    	    }
			    	    break;
			  	    }
    	      case 20:
		           {
		      	    Afficher(Et,n);
    		        break;
     	           }
     	      case 21:
		           {
		           	int k=max(Et,n);
                    printf("la moyenne max est : %f \n",Et[k].moy);
    		        break;
     	           }
              case 22:
		           {
		           	int k=min(Et,n);
		            printf("le moyenne min est : %f \n",Et[k].moy);
    		        break;
     	           }
     	      case 23:
		           {
		           	float val;
		           	printf("quelle valeur vous voullez chercher son occurence ? ");
		           	scanf("%f",&val);
		            printf("%f se repete %d fois \n",val,occurrence(Et,n,val));
    		        break; 
				   }
     	      case 24:
		           {
		           	Etudiant var;
		           	int p;
 	        	    printf("donner le nom de l'etudiant a inserer: ");
 	                var.nom=(char*)malloc(sizeof(char)*20);
                    scanf("%s",var.nom);
		            printf("donner le code de l'etudiant a inserer: ");
	                scanf("%d",&var.code);
	                printf("donner la moyenne de l'etudiant a inserer: ");
 	                scanf("%f",&var.moy);
 	                inserer(Et,&n,p,var);
    		        break;
     	           }
     	      case 25:
		           {
		            permuter_1(Et,n);
		            printf("permute avec succes \n");
    		        break;
     	           }
     	      case 26:
		           {
		            permuter_2(Et,n);
		            printf("permute avec succes \n");
    		        break;
     	           }
     	     case 27:
		           {
		            int R,k;
		            printf("donner le code de l'etudiant que vous voullez chercher: ");
		            scanf("%d",&R);
		            k=recherche_pos(Et,n,R);
		            if(k==(-1))
		            {
		            	printf("cet etudiant n'existe pas \n");
		            }
		            else
		            {
		            	Afficher1(Et,k);
		            }
    		        break;
     	           }
     	     case 28:
		           {
		           	int C,pos;
		            printf("donner le code de l'etudiant que vous voullez supprimer: ");
		            scanf("%d",&C);
		            pos=recherche_pos(Et,n,C);
		            supprimer(Et,&n,pos);
    		        break;
     	           }
     	     case 29:
		           {
                    tri_a_bulle(Et,n);
                    printf("tri effectuer avec succes \n");
                    break;
     	           }
			 case 30:
		           {
                    tri_par_insertion(Et,n);
                    printf("tri effectuer avec succes \n");
                    break;
     	           }
			 case 31:
		           {
                    tri_fusion(Et,n);
                    printf("tri effectuer avec succes \n");
                    break;
     	           }    	           
			 case 32:
		           {
                    tri_rapide(Et,n);
                    printf("tri effectuer avec succes \n");
                    break;
     	           }       	           
 			 case 33:
		           {
                    tri_par_selection(Et,n);
                    printf("tri effectuer avec succes \n");
                    break;
     	           } 
        }
    }
	return 0;

**Chanur** · 19/10/2014, 17h58

J'abandonne.
J'ai écrit le main le plus simple. Ça ne plante pas.

Code:

int main ()
{
    Cellule *ll=NULL;
    Cellule * p = chercher_chaine_double (0, ll);
    return 0;
}

Evidemment, j'aurais pu faire plus compliqué, mais la probabilité que j'écrive la même erreur que toi est tellement faible que ça n'en vaut pas la peine.

**hanafi_hamza** · 19/10/2014, 18h59

Je comprend pas pourquoi tu met "0" au lieu de "code" ?

Code:

{
    Cellule * p = chercher_chaine_double (0, ll);

}

**Chanur** · 19/10/2014, 19h13

C'est une valeur comme une autre ...
J'aurais pu aussi mettre 3257, mais ç'aurait été plus long à taper.

**Chanur** · 21/10/2014, 00h15

Ou, si tu veux que je présente les choses autrement, tu dis :

Envoyé par hanafi_hamza

Dans le main(): lorsque je fais cette affectation le programme se bloque !!

Code:

cellule *f;
f=chercher(code,malistechainee);

Merci de m'aider

Et tu refuses absolument de donner la partie du programme où se trouve cette ligne.
J'ai donc écrit le main le plus simple où elle figure et ça ne bloque pas. Point final.
C'est à toi de voir si tu veux de l'aide ou pas.

fonction recherche dans une liste chainée

fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Re : fonction recherche dans une liste chainée

Discussions similaires

Maximum dans une liste chainée

Fonction recherche de nombres (liste chainée en C)

liste chainée

liste chainée en C

liste chainée