40 PROCÉDURES POUR LA GESTION D'UNE LISTE LINÉAIRE CHAÎNÉE ! C++4.52

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


	struct pointer
			{
			int field; // Ce premier champ sert à contenir l'information -en l'occurrence l'entier-
						  // de chaque noeud de la chaine linéaire
			struct pointer *link; // C'est le pointeur vers la cellule suivante
			};
	typedef struct pointer cell;    // Ici on tient à définir un type 'cell' sur lequel
											  // on va travailler tout au long du code


	void display();                     //déclaration de la procédure d'affichage
	cell*create_my_linked_list();       // Déclaration de la fonction qui se charge de
													//      l'implémentation de la liste
	void remove_the_first_element();    // Déclaration de la procédure qui supprime le
													//      premier élément de notre liste
	void remove_the_last_element();     // Déclaration de la procédure qui supprime le
													//      dernier élément de la liste
	void token_removing();              // Déclaration de la procédure de suppression
													//       d'un élément par indice
	int counting_the_number_of_elements();  // Cette fonction sert à compter le nombre
													// d'éléments de la liste afin de l'utiliser dans
													// les opérations de mise à jour par indice
													// ou tout simplement pour s'en rendre compte
													//        à gré de l'utilisateur
	void seek_if_val_exists();          // Cette procédure sert à confirmer l'existance
													//       ou non d'un élément dans la liste
	void seek_the_last_val_occ();       // déclaration de la procédure qui recherche la
													// dernière occurrence d'une valeur souhaitée
	void seek_the_number_of_val_occ();  //  Déclaration de la procédure qui fournit le
													//     nombre d'occurrence d'une valeur
	void if_sorted_linked_list();       //  Déclaration de la procédure qui vérifie
													//  si la liste est ordonnée en décroissance.

	void check_if_sorted_linked_list2();      // Déclaration de la procédure qui vérifie  si
													// la liste est trié en terme de croissance
	cell *create_a_linked_list_without_inverting_it(); // Déclaration de la procédure qui crée la liste
															 // dans l'ordre de leur arrivée,i.e: la liste
															 // ainsi créee ne sera pas inversée lors de son
															 // affichage contrairement à la précédente procédure
															 // de création
	void quick_sort_my_list();                 // Déclaration de la procédure qui trie notre liste
															 // par ordre croissant
	void quick_sort_my_list2();                // Déclaration de la procédure qui trie notre liste
															 // par ordre croissant
	void remove_before_a_given_token();
	cell*head=NULL;
	cell *created_linked_list=NULL;
	cell *not_reversed=NULL;                   // Ce pointeur pour recevoir la liste
															 // créee mais non inversée

	void add_an_element_at_the_begining_list(); // Déclaration de la procédure qui ajoute un élément
															  // en tete de la liste
	void ad_an_element_at_the_end_of_the_list(); //  Déclaration de la procédure qui insère
																// un élément en queue de la liste
	void _delete_my_list();                      // Déclaration de la procédure qui efface
																// tous les éléments de notre liste
	void _if_this_element_exists();              // Déclaration de la procédure qui vérifie
																// l'existance d'un élément dans la liste
	void check_the_negative_elements();          // Déclaration de la procédure qui
																// affiche tous les éléments négatifs
																// de la liste
	void check_the_positive_elements();        // Déclaration de la procédure qui affiche
																// tous les éléments positifs de la liste

	void remove_all_the_negative_values();       // Déclaration de la procédure qui supprime
																// toutes les valeurs négatives de la liste
	void remove_all_the_positive_values();       // Déclaration de la procédure qui supprime
																// toutes les valeurs positives de la liste
	void positive_elements_counting();           // Déclaration de la procédure qui délivre
																// le nombre d'éléments positifs de la liste
	void negative_elements_counting();           // Déclaration de la procédure qui délivre
																// le nombre d'éléments négatifs de la liste
	void sup_the_middle_values();						// Déclaration de la procédure qui supprime les valeurs
																// qui sont entre la tete et la queue de la liste
	void remove_all_the_uneven_values();          // Procédure qui supprime toutes les valeurs impaires
	void remove_all_the_fair_values();           // Procédure de suppression de toutes les valeurs paires
	void remove_all_the_multiples_of_a_given_value(); // Procédure de suppression des multiples d'une nombre
	void check_the_value_div_elements();              // Affichage des diviseurs d'un entier
	void check_the_value_multiple_elements();         // Affichage des multiples d'un entier
	void remove_all_the_value_occ();                  // Suppression de toutes les occuurences
																	  // d'une valeur
	void invert_my_linked_list();                     // Pour créer la liste miroir de
																	  // la liste précédemment saisie
	void multiply_my_linked_list_elements();          // Pour multiplier les éléments de la liste
																	  // par un entier
	void divide_my_linked_list_elements();            // Pour diviser les éléments de la liste
																	  // par un entier
	void add_an_integer_to_my_linked_list_elements();  // Ajouter le meme entier à tous les éléments de
																		// la liste
	void minus_an_integer_from_my_linked_list_elements(); // Pour soustraire le meme entier
																		  // de tous les éléments de la liste
	void minus_an_integer_from_given_linked_list_element(); // pour soustraire un entier à un
																			 // élément donné de la liste
	void add_an_integer_for_given_linked_list_element(); // Additionner un entier à toutes les occurrences
																		  // d'un élément donné de la liste
	void multiply_an_integer_by_given_linked_list_element(); // Multiplier toutes les occurrences
																			  // d'un élément par un entier



	/*  **************************  */
	/*                              */
	/* Début du programme principal */
	/*                              */
	/*  *************************** */
	void main(void)

	{
	int my_choice;
	char reply;
	int number_of_elements;


	created_linked_list=create_my_linked_list();
	clrscr();
	do
	 {
	  puts("\t\t\t\tGestion des L.L.C.");
	  cout<<"\t\tBillal BEGUERADJ all rights reserved";
	  puts("\n\t\tBienvenue au menu :\n\n");
	  puts("\t\t1\t2\t3\t4");
	  puts("\t\t5\t6\t7\t8");
	  puts("\t\t9\t10\t11\t12");
	  puts("\t\t13\t14\t15\t16");
	  puts("\t\t17\t18\t19\t20");
	  puts("\t\t21\t22\t23\t24");
	  puts("\t\t25\t26\t27\t28");
	  puts("\t\t29\t30\t31\t32");
	  puts("\t\t33\t34\t35\t36");
	  puts("\t\t37\t38\t39\t40");
	  cout<<"\n\n\tRéferrez-vous au fichier PDF ou HTML du code pour voire \n";
	  cout<<"\t\t   la correspondance de ces numéros.";
	  cout<<"\n \n\tVeuillez saisir votre choix :    ";
	  cin>>my_choice;
	  switch(my_choice)
		 {

		 case 1: display();
					break;
		 case 2: remove_the_first_element();
					break;
		 case 3: created_linked_list=create_my_linked_list();
					break;
		 case 4: remove_the_last_element();
					break;
		 case 5: number_of_elements=counting_the_number_of_elements();
					printf("La liste renferme %d éléments",number_of_elements);
					break;
		 case 6: token_removing();
					break;
		 case 7: seek_if_val_exists();
					break;
		 case 8: seek_the_last_val_occ();
					break;
		 case 9: seek_the_number_of_val_occ();
					break;
		 case 10: if_sorted_linked_list();
					break;
		 case 11: check_if_sorted_linked_list2();
					break;
		 case 12: not_reversed=create_a_linked_list_without_inverting_it();
					 break;
		 case 13: quick_sort_my_list();
					 break;
		 case 14: quick_sort_my_list2();
					 break;
		 case 15: remove_before_a_given_token();
					 break;
		 case 16: add_an_element_at_the_begining_list();
					 break;
		 case 17: ad_an_element_at_the_end_of_the_list();
					 break;
		 case 18: _delete_my_list();
					 break;
		 case 19: _if_this_element_exists();
					 break;
		 case 20: check_the_negative_elements();
					 break;
		 case 21: check_the_positive_elements();
					 break;
		 case 22: remove_all_the_negative_values();
					 break;
		 case 23:remove_all_the_positive_values();
					break;
		 case 24: positive_elements_counting();
					break;
		 case 25: negative_elements_counting();
					break;
		 case 26: sup_the_middle_values();
					break;
		 case 27: remove_all_the_uneven_values();
					break;
		 case 28: remove_all_the_fair_values();
					break;
		 case 29: remove_all_the_multiples_of_a_given_value();
					break;
		 case 30: check_the_value_div_elements();
					break;
		 case 31: check_the_value_multiple_elements();
					break;
		 case 32: remove_all_the_value_occ();
					break;
		 case 33: invert_my_linked_list();
					break;
		 case 34: multiply_my_linked_list_elements();
					break;
		 case 35: divide_my_linked_list_elements();
					break;
		 case 36: add_an_integer_to_my_linked_list_elements();
					break;
		 case 37: minus_an_integer_from_my_linked_list_elements();
				  break;
		 case 38: minus_an_integer_from_given_linked_list_element();
				  break;
		 case 39: add_an_integer_for_given_linked_list_element();
				  break;
		 case 40: multiply_an_integer_by_given_linked_list_element();
				  break;
		 default :
					cout<<"Choix inexistant !";
		 }
		 cout<<"\nAppuez sur ENTREE pour continuer sinon sur la lettre q : ";
		 reply=getch();
		 }while((reply!='q')&&(reply!='Q'));     // On évite l'amalgame des traits de
															 // la lettre q (miniscule ou majuscule
															 //               soit-elle )




	 } /* Fin du programme principal */




	/*   ****************************************  */
	/*                                             */
	/*    Implémentation de la fonction qui se     */
	/*           charge de la création de          */
	/*                notre liste                  */
	/*                                             */
	/*  *****************************************  */
	cell *create_my_linked_list()
	{

	/* Déclaration des paramètres locaux de cette fonction */

	int n;  /* Pour le nombre d'éléments à saisir */
	int i;  /* Un compteur jusqu'à n */
	int number; /* l'entier 'i' à saisir */
	cell *ptr; /* Pointeur intermédiaire */

	do
	 {
	 clrscr();
	 cout<<"\tDonnez le nombre d\'éléments de votre liste:  ";
	 cin>>n;
	 }while(n<=0);   /* Ici, il est recommandé de forcer l'utilisateur à
								saisir quand meme au moins un entier pour nous permettre
								procéder aux différentes opérations possibles sur les listes;
								auquel cas à quoi bon, d'ailleurs !?
						  */


	for(i=0;i<n;i++)
	  {
		 ptr=(cell*)malloc(sizeof(cell));
		 cout<<"Veuillez Saisir un entier :  ";
		 scanf("%3d",&number); // On puit supprimer la variable 'number'
		 ptr->field=number;      //dans ce cas, on écrirai simplement
		 ptr->link=head;         // scanf("%d",&p->info); et puis, p->svt=head;
		 head=ptr;
	  }
		return head;
	  }



	 /*  **************************************************************  */
	 /*                                                                  */
	 /*      Définition de la procédure d'affichage des éléments         */
	 /*                        de la liste                               */
	 /*                                                                  */
	 /*  *************************************************************** */
	 void display()
		{
		cell*node=head;
		if(node==NULL)
		  {
		  cout<<" La liste est vide! -suppression de tous les éléments-";
		  }else
			  {   cout<<" Voici la liste résultante : \n";
					while(node!=NULL)
					  {
					  printf("%3d",node->field);
					  node=node->link;
					  }
			  }
		  }




	 /*  ************************************************************** */
	 /*                                                                 */
	 /*                                                                 */
	 /*  Implémentation de la procédure qui fait la suppression         */
	 /*                  du premier élément de notre                    */
	 /*                           liste                                 */
	 /*                                                                 */
	 /*                                                                 */
	 /*  ************************************************************** */
	 void remove_the_first_element()
		{

		// Un pointeur-variable locale
		cell *ptr;
		if (head==NULL)    // On teste si la liste est vide ou pas
			{
			puts("\n La liste est déjà vide !");

			}else       // Si la liste n'est pas vide on procède à la suppression
				 {
				 ptr=head;
				 head=head->link;
				 free(ptr);
				 if(head==NULL)
					{
					puts("\n Vous venez de supprimer l\'unique élément de la liste !");

					}else
						{
						 display();

						}
				 }
		}





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /*       Implémentation de la procedure qui se charge  de la              */
	 /*          suppression du dernier élément de la liste                    */
	 /*                                                                        */
	 /*  ********************************************************************* */
	 void remove_the_last_element()
	 {
	 cell *ptr=head;//pointeur local à cette procedure
	 cell *ptr2=head;

	 if(ptr==NULL)
	  {
		cout<<"La liste est déjà vide !"; // On teste si la liste est vide
	  }else
			{
			if(ptr->link==NULL) // Le cas où la liste renferme un seul élément
			  {
			  head=NULL;        // Il faut commencer pat ceci dans le souci de la
			  free(ptr);        //     protection de la mémoire
			  cout<<" Vous venez de supprimez l\'unique élément de la liste !";
			  }else
				  {
					 while(ptr->link!=NULL)
						 {
						  ptr2=ptr;
						  ptr=ptr->link;
						  }
					 ptr2->link=NULL;
					 free(ptr);
					 display();
				  }
			  }
			}






	 /*  ********************************************************************* */
	 /*                                                                        */
	 /*          Implémentation de la fonction qui prend en charge             */
	 /*             le comptage du nombre d'éléments que la                    */
	 /*                          liste contient                                */
	 /*                                                                        */
	 /*  ********************************************************************* */

	 int counting_the_number_of_elements()
	 {
	 int i=0;    // Compteur du nombre d'éléments
	 cell *ptr=head;
	 if(ptr==NULL)
		{
		return 0;
		}else
			{
			  while(ptr!=NULL)
					{
					 i++;
					 ptr=ptr->link;
					 }
			 return i;
			 }
	 }




	  /*  ********************************************************************* */
	 /*                                                                        */
	 /*    Implémentation de la procédure qui se charge de la suppression      */
	 /*                         d'un élément par indice                        */
	 /*                                                                        */
	 /*  ********************************************************************  */
	 void token_removing()
	 {
	 int token; /* indice de l'élément à supprimer */
	 int length=counting_the_number_of_elements(); // longuer de la liste
	 int counter=1;
	 cell*ptr1=head;
	 cell*ptr2=head;

	 do
	  {
		cout<<" Donnez l\'indice de l'élément à supprimer (à partir de 1) :   ";
		cin>>token;
	  }while(token<=0);
	 if(token>length)
		{
		printf(" Votre liste renferme moins de %d éléments !");
		}else
			{
			 if(token==1)
			  {
			  remove_the_first_element();
			  }else
				 {
					while(counter!=token)
					 {
					 ptr2=ptr1;
					 ptr1=ptr1->link;
					 counter++;
					 }
				printf(" L\'élément d\'indice %d existe ;",token);
				printf("il s\'agit de %d ",ptr1->field);
				ptr2->link=ptr1->link;
				free(ptr1);
				printf("\n Et voici la liste après la suppression de l\'élément d'indice %d\n",token);
				display();
		  }
		}
	 }



	 /*  ********************************************************************  */
	 /*                                                                        */
	 /*                                                                        */
	 /*  Implémentation de la procédure qui vérifie la première occurrence     */
	 /*               d'une valeur donnée dans la liste                        */
	 /*                                                                        */
	 /*                                                                        */
	 /*  ********************************************************************* */
	 void seek_if_val_exists()
	 {
	 int val;     // Pour la valeur à vérifier l'existance au sein de la liste
	 int pos=1;   // Pour l'indice de la 1ère occurrence de la valeur val
					// val à chercher dans la liste -le cas où elle s'y trouve.
	 cell *ptr=head;
	 puts(" Introduisez la valeur à vérifier l'existance dans la liste :");
	 cin>>val;
	 while((ptr!=NULL)&&(ptr->field!=val))
		  {
			pos++;
			ptr=ptr->link;
		  }
	 if(ptr!=NULL)
		{
		printf(" %d existe en 1ère occurrence à la position %d dans la liste.",val,pos);
		}else
			{
			printf(" La liste ne renferme pas la valeur %d.",val);
			}
	 }


	 /*  ********************************************************************* */
	 /*                                                                        */
	 /*  Implémentation de la fonction qui délivre l'indice de la dernière     */
	 /*                  occurrence d'une valeur donnée                        */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void seek_the_last_val_occ()
	 {
	 int pos=0;  // Pour l'indice de la dernière occurrence
					 //      si val existe
	 int val1;    // Pour la valeur à chercher dans la liste
	 cell*ptr=head;   // Pointeur de parcours
	 cout<<"Saisissez une valeur pour vérifier sa dernière occurrence.\n";
	 scanf("%d",&val1);
	 if(ptr==NULL)
		{
		 puts(" Désolé, mais la liste est vide !");
		}else
			{
			 while(ptr!=NULL)
				 {
				 if(ptr->field==val1)
					{
					pos++;
					}
				 ptr=ptr->link;
				 }if(pos==0)
					{
					 printf("La valeur %d n\'existe pas dans la liste.",val1);
					}else
						{
						 printf(" %d existe en dernière occurrence dans la liste en position %d",val1,pos);
						}
			 }
	 }





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /*  Implémentation de la procédure qui délivre le nombre d'occurrences    */
	 /*                     d'une valeur donnée                                */
	 /*                                                                        */
	 /*  ********************************************************************  */
	 void seek_the_number_of_val_occ()
	 {
	 int pos=0;  // Pour l'indice de la dernière occurrence
					 //      si val existe
	 int val1;    // Pour la valeur à chercher dans la liste
	 cell*ptr=head;   // Pointeur de parcours
	 cout<<"Saisissez une valeur pour vérifier sa dernière occurrence.\n";
	 scanf("%d",&val1);
	 if(ptr==NULL)
		{
		 puts(" Désolé, mais la liste est vide !");
		}else
			{
			 while(ptr!=NULL)
				 {
				 if(ptr->field==val1)
					{
					pos++;
					}
				 ptr=ptr->link;
				 }if(pos==0)
					{
					 printf("La valeur recherchée n\'existe pas dans la liste.");
					}else
						{
						 printf(" %d existe en %d exemplaires dans la liste",val1,pos);
						}
			 }
	 }



	 /*  ********************************************************************  */
	 /*                                                                        */
	 /*        Implémentation de la procédure qui vérifie si notre             */
	 /*                       est triée en décroissant                         */
	 /*                                                                        */
	 /*  ********************************************************************* */
	 void if_sorted_linked_list()
	 {
	 cell*ptr=head;
	 if(ptr==NULL)
		{
		puts(" La liste est vide : donc triée.");
		}else
		  {
		  if(ptr->link==NULL)
			{
			 cout<<" La liste renferme un seul élément : donc triée.";
			}else
				{
				while((ptr->link!=NULL)&&(ptr->field>=ptr->link->field))
					 {
					 ptr=ptr->link;
					 }if(ptr->link==NULL)
						 {
						  cout<<" La liste est triée en décroissant.\n";
						 }else
							{
							 cout<<" La liste n\'est pas ordonnée en décroissance.\n";
							}
				 }
			}
	}





	 /*  ********************************************************************  */
	 /*                                                                        */
	 /*        Implémentation de la procédure qui vérifie si notre             */
	 /*                         est triée en croissant                         */
	 /*                                                                        */
	 /*  ********************************************************************* */
	 void check_if_sorted_linked_list2()
	 {
	 cell*ptr=head;     // Pointeur local qui reçoit la tete de liste principale
	 if(ptr==NULL)
		{
		puts(" La liste est vide : donc triée.");      // On teste si la liste est vide
		}else
		  {
		  if(ptr->link==NULL)
			{
			 cout<<" La liste renferme un seul élément : donc triée."; //C'est le cas où la liste possède un unique élément
			}else
				{
				while((ptr->link!=NULL)&&(ptr->field<=ptr->link->field))
					 {
					 ptr=ptr->link;
					 }if(ptr->link==NULL)
						 {
						  cout<<" La liste est triée en croissant.\n";
						 }else
							{
							 cout<<" La liste n\'est pas ordonnée en croissance.\n";
							}
				 }
			}
	}




	/* *********************************************************************** */
	/*                                                                         */
	/*    Implémentation de la procédure qui crée une liste sans               */
	/*              l'inverser à l'affichage                                   */
	/*                                                                         */
	/* *********************************************************************** */
	cell* create_a_linked_list_without_inverting_it()
	{
	 // Déclaration des variables locales
	 cell*precedent=NULL;  // Pour le pointeur qui sauvegarde l'adresse du pointeur
								  // précédent déja crée
	 cell*actual=NULL;     // Pour le pointeur courant
	 int datum;
	 int err;


	 do
	  {
	  cout<<" Veuiellez saisir un entier (une lettre pour arreter) :  ";
	  err=scanf("%d",&datum);
	  if(err<=0) break; // Pour rendre le nombre de variables lues sans erreur
	  actual=(cell*)malloc(sizeof(cell));
	  actual->field=datum;
	  if(precedent==NULL)
		 {
		 head=actual;
		 }else
			{
			precedent->link=actual;
			}
	  precedent=actual;
		}while(1);  // fin de la boucle do
	  actual->link=NULL;
	  return head;
	  }




	  /* ********************************************************************* */
	  /*                                                                       */
	  /*      Implémentation de la procédure qui trie notre liste              */
	  /*                    dans l'ordre croissant                             */
	  /*                                                                       */
	  /* ********************************************************************* */
 void	  quick_sort_my_list()
/* le premier ne sera peut-être plus le même donc passage par adresse */
 {
  int ok;
  cell *precedent=NULL;
  cell*actual=NULL;
  cell*after=NULL;
  do
	{
	 ok=1; /* vrai */
	 precedent=NULL;
	 actual=head;
	 after=actual->link;
	 while(after!=NULL)
	  {
		if(actual->field > after->field)
		 {
		  ok=0;
		  if(precedent!=NULL) precedent->link=after; else head=after;
		  actual->link=after->link;
		  after->link=actual;
		 }
		precedent=actual;
		actual=after;
		after=actual->link;
	  }
	}
  while(!ok);
  puts("\n ---  Tri décroissant de la liste  ---");
  display();  // Appel à la fonction d'affichage
 }





	  /* ********************************************************************* */
	  /*                                                                       */
	  /*      Implémentation de la procédure qui trie notre liste              */
	  /*                      par ordre décroissant                            */
	  /*                                                                       */
	  /* ********************************************************************* */
 void	  quick_sort_my_list2()
/* le premier ne sera peut-être plus le même donc passage par adresse */
 {
  int ok;
  cell *precedent=NULL;
  cell*actual=NULL;
  cell*after=NULL;
  do
	{
	 ok=1; /* vrai */
	 precedent=NULL;
	 actual=head;
	 after=actual->link;
	 while(after!=NULL)
	  {
		if(actual->field < after->field)
		 {
		  ok=0;
		  if(precedent!=NULL) precedent->link=after; else head=after;
		  actual->link=after->link;
		  after->link=actual;
		 }
		precedent=actual;
		actual=after;
		after=actual->link;
	  }
	}
  while(!ok);
  puts("\n  ---  Tri croissant de la liste  ---");
  display();  // appel à la fonction d'affichage
 }



 /* ************************************************************************* */
 /*                                                                           */
 /*   Implémentation de la procédure qui supprime l'élement qui vient         */
 /*             après l'indice d'un autr élément de la liste                  */
 /*                                                                           */
 /* ************************************************************************* */
 void remove_before_a_given_token()
 {
 cell*ptr1=head;
 cell*ptr2=ptr1->link;
 cell*ptr3=NULL;
 int k=0;
 int index; // Pour l'indice de l'élément dont on veut supprimer le prédécesseur
 int length =counting_the_number_of_elements(); // Pour s'enquérir sur la longueur de la liste

 if(length==0)
	{
	cout<<" Désolé, la liste est déjà vide !";
	}
 if(length==1)
		 {
		 cout<<" La liste contient un seul élément qui n'a pas de sucesseur !";
		 }
 if(length>=2)
  {
  do
	 {
	 cout<<"\n L'indice (>=2) de l'élément à suprrimer son successeur : ";
	 cin>>index;
	 if((index==0)||(index==1))
		{
		cout<<" On ne puit supprimer avant l'indice 0 ou 1 !";
		continue;
		}
  }while((index==0)||(index==1));
  }

 if(index>length)
				  {
					printf(" La liste contient moins de  %d éléments !",index);
					}
 if((ptr2->link==NULL)&&(index==2))
						  {
						  ptr1->link=NULL;
						  free(ptr1);
						  display();
						  };
 if(ptr2->link!=NULL)
	 {
	  while((k<index)&&(ptr2->link!=NULL))
			{
				ptr3=ptr1;
				ptr2=ptr2->link;
				ptr1=ptr1->link;
				k++;
			}
		ptr3->link=ptr1->link;
		ptr1->link=NULL;
		free(ptr1);
		display();
	 }

	 }





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /*     Implémentation de la procédure qui insère un élément en            */
	 /*                       tete de la liste                                 */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void add_an_element_at_the_begining_list()
	 {

	 cell*p=NULL;
	 int value;     // Pour l'entier à y insérer en tete
	 cout<<" Veuillez saisir l\'entier à insérer en tete de la liste :  ";
	 scanf("%d",&value);
	 p=(cell*)malloc(sizeof(cell));
	 p->field=value;
	 p->link=head;
	 head=p;
	 puts(" *** Insertion en tete ***");
	 display(); // Appel à la procédure d'affichage pour voir le résultat
					//d'insertion
	 }




	 /*  ********************************************************************* */
	 /*                                                                        */
	 /*      Implémentation de la procédure qui insère un élément en fin       */
	 /*                            de la liste                                 */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void ad_an_element_at_the_end_of_the_list()
	 {
	 cell *p=NULL;
	 cell *ptr=head;

	 int value;

	 cout<<" Veuillez sasir l\'entier à insérer en queue de la liste : ";
	 cin>>value;
	 p=(cell*)malloc(sizeof(cell));
	 p->field=value;
	 p->link=NULL;
	 if(ptr==NULL) // c'est le cas où la liste est vide
		{
		ptr=p;
		head=ptr;
		display();
		}else
			{
			if(ptr->link==NULL)  // le cas où la liste contient un seul élément
			  {
			  ptr->link=p;
			  head=ptr;
			  display();
			  }else
				 {
				  while(ptr->link!=NULL) // le cas où la liste contient 2 ou plus d'éléments
					{
					ptr=ptr->link;
					}
				 ptr->link=p;
				 display();
				}
				}
	 }




	 /* ********************************************************************** */
	 /*                                                                        */
	 /*     Implémentation de la procédure qui efface toute la liste           */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void _delete_my_list()
	 {
	 cell*p1=head;
	 cell*p2=NULL;
	 if(p1==NULL)
		{
		cout<<" La liste est déjà vide !";
		}else
		  {
		  while(p1!=NULL)
			  {
			  p2=p1->link;
			  free(p1);
			  p1=p2;
			  }
			  head=p1;
			  cout<< " La liste est à présent vierge (choisir 1 pour confirmation)";
			  }
	 }


	 /* ********************************************************************** */
	 /*                                                                        */
	 /*  Implémentation de la procédure qui vérifie si un élément existe       */
	 /*                        dans la liste                                   */
	 /*                                   													*/
	 /* ********************************************************************** */
	 void _if_this_element_exists()
	 {
	 cell *ptr=head;
	 int value;
	 cout<<" Veuillez saisir l\'entier à vérifier l\'existance dans la liste :  ";
	 cin>>value;
	 if(ptr==NULL)
		{
		cout<<" Désolé, la liste est vide !";
		}else
			{
			while((ptr!=NULL)&&(ptr->field!=value))
			  {
			  ptr=ptr->link;
			  }
			  if(ptr==NULL)
				 {
				 printf(" %d n\'existe dans la liste.",value);
				 }else
					{
					printf(" %d Existe bien dans la liste.",value);
					}
			}
	  }


	  /* ********************************************************************* */
	  /*                                                                       */
	  /*  Implémentation de la procédure qui affiche les éléments négatifs     */
	  /*                    de la liste linéaire chainée                       */
	  /*                                                                       */
	  /* ********************************************************************* */
	  void check_the_negative_elements()
	  {
		int k=0;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  puts(" Voici la liste des éléments négatifs de la liste :");
		  while(ptr!=NULL)
			  {
			  if(ptr->field<0)
				 {
				 printf("%4d",ptr->field);
				 k++;
				 }
				 ptr=ptr->link;
				 }
		  if(k==0)
				  {
				  cout<<" La liste ne renferme aucun élément négatif.";
				  }

		}
	 }



	  /* ********************************************************************* */
	  /*                                                                       */
	  /*  Implémentation de la procédure qui affiche les éléments positis      */
	  /*                    de la liste linéaire chainée                       */
	  /*                                                                       */
	  /* ********************************************************************* */
	  void check_the_positive_elements()
	  {
		int k=0;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  puts(" Voici la liste des éléments positifs de la liste :");
		  while(ptr!=NULL)
			  {
			  if(ptr->field>0)
				 {
				 printf("%4d",ptr->field);
				 k++;
				 }
				 ptr=ptr->link;
				 }
		  if(k==0)
				  {
				  cout<<" La liste ne renferme aucun élément positif.";
				  }

		}
	 }


	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui supprime toutes les valeurs négatives*/
	 /*                            de la liste                                 */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void remove_all_the_negative_values()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  int k=0;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  while(ptr!=NULL)
			  {
			  if(ptr->field>0)
				 {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field;
				 p->link=pp;
				 pp=p;
				 k++;
				 }
				 ptr=ptr->link;
				 head=pp;
			 }
		  }
		  if(k!=0)
			{
			puts(" Suppression des éléments négatifs :");
			display();
		  }
		}





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui supprime toutes les valeurs positives*/
	 /*                            de la liste                                 */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void remove_all_the_positive_values()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  int k=0;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  while(ptr!=NULL)
			  {
			  if(ptr->field<0)
				 {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field;
				 p->link=pp;
				 pp=p;
				 k++;
				 }
				 ptr=ptr->link;
				 head=pp;
			 }
		  }
		  if(k!=0)
			{
			  puts(" Suppression des éléments positifs :");
			  display();

		  }
		}



		/* ********************************************************************* */
	  /*                                                                       */
	  /*  Implémentation de la procédure qui affiche les éléments positis      */
	  /*                    de la liste linéaire chainée                       */
	  /*                                                                       */
	  /* ********************************************************************* */
	  void positive_elements_counting()
	  {
		int k=0;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  while(ptr!=NULL)
			  {
			  if(ptr->field>0)
				 {
				 k++;
				 }
				 ptr=ptr->link;
				 }
		  if(k==0)
				  {
				  cout<<" La liste ne renferme aucun élément positif.";
				  }
				  else
					{
					printf(" La liste renferme %d éléments positifs.",k);
					}

		}
	 }




		/* ********************************************************************* */
	  /*                                                                       */
	  /*  Implémentation de la procédure qui affiche les éléments négatifs     */
	  /*                    de la liste linéaire chainée                       */
	  /*                                                                       */
	  /* ********************************************************************* */
	  void negative_elements_counting()
	  {
		int k=0;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  while(ptr!=NULL)
			  {
			  if(ptr->field<0)
				 {
				 k++;
				 }
				 ptr=ptr->link;
				 }
		  if(k==0)
				  {
				  cout<<" La liste ne renferme aucun élément négatif.";
				  }
				  else
					{
					printf(" La liste renferme %d éléments négatifs.",k);
					}

		}
	 }



	 /* ********************************************************************** */
	 /*																								*/
	 /*   Implémentation de la procédure qui supprime les valeurs qui sont     */
	 /*                 entre la tete et la queue										*/
	 /*                        de la liste                                     */
	 /*																								*/
	 /* ********************************************************************** */
	 void sup_the_middle_values()
	 {
	 cell*p=NULL;
	 cell*ptr=head;

	 if(ptr==NULL)
	  {
	  cout<<" La liste est vide !";
	  }else
		 {
		 if(ptr->link==NULL)
			{
			cout<<" La liste contient un seul élément : cet élément est à la fois la tete et la queue!.";
			}else
			  {
			  p=(cell*)malloc(sizeof(cell));
			  p->field=ptr->field;
			  p->link=NULL;
			  head=p;
			  while(ptr->link!=NULL)
					{
					ptr=ptr->link;
					head->link=ptr;
					}
					puts(" Supression des éléments existants entre la tete et la queue :");
					display();
			 }

		 }
	}






	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui supprime tous les nombres           */
	 /*                        impairs de la liste                             */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void remove_all_the_uneven_values()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  int k=0;

	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  while(ptr!=NULL)
			  {
			  if(ptr->field%2==0)
				 {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field;
				 p->link=pp;
				 pp=p;
				 k++;
				 }
				 ptr=ptr->link;
				 head=pp;
			 }
		  }
		  if(k!=0)
			{
			  puts(" Suppression des valeurs impaires:");
			  display();

		  }else
			{
			cout<<" ... Liste vide !.";
			}
		}





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui supprime tous les nombres           */
	 /*                          pairs de la liste                             */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void remove_all_the_fair_values()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  int k=0;

	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  while(ptr!=NULL)
			  {
			  if(ptr->field%2!=0)
				 {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field;
				 p->link=pp;
				 pp=p;
				 k++;
				 }
				 ptr=ptr->link;
				 head=pp;
			 }
		  }
		  if(k!=0)
			{
			  puts(" Suppression des valeurs paires:");
			  display();

		  }else
			{
			cout<<" ... Liste vide !.";
			}
		}





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui supprime tous les nombres           */
	 /*                          pairs de la liste                             */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void remove_all_the_multiples_of_a_given_value()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  int k=0;
	  int value;

	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
			cout<<" Saisissez le multiple de quel nombre que vous souhaitez supprimer: ";
			cin>>value;
		  while(ptr!=NULL)
			  {
				if(ptr->field%value!=0)
				 {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field;
				 p->link=pp;
				 pp=p;
				 k++;
				 }
				 ptr=ptr->link;
				 head=pp;
			 }
		  }
		  if(k!=0)
			{
			  printf(" Suppression des multiples de %d\n",value);
			  display();

		  }else
			{
			cout<<" ... Liste vide !.";
			}
		}






	  /* ********************************************************************* */
	  /*                                                                       */
	  /*  Implémentation de la procédure qui affiche les éléments positis      */
	  /*                    de la liste linéaire chainée                       */
	  /*                                                                       */
	  /* ********************************************************************* */
	  void check_the_value_div_elements()
	  {
		int k=0;
	  cell*ptr=head;
	  int value;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Vous souhaitez afficher les diviseurs de quel entier ?  ";
		  cin>>value;
		  printf(" Voici la liste des diviseurs de %d :\n",value);
		  while(ptr!=NULL)
			  {
			  if(value%ptr->field==0)
				 {
				 printf("%4d",ptr->field);
				 k++;
				 }
				 ptr=ptr->link;
				 }
		  if(k==0)
				  {
				  printf(" La liste ne renferme pas des diviseurs de %d.",value);
				  }

		}
	 }






	  /* ********************************************************************* */
	  /*                                                                       */
	  /*  Implémentation de la procédure qui affiche les multiples d'un        */
	  /*                    dans la liste linéaire chainée                     */
	  /*                                                                       */
	  /* ********************************************************************* */
	  void check_the_value_multiple_elements()
	  {
		int k=0;
	  cell*ptr=head;
	  int value;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Vous souhaitez afficher les multiples de quel entier ?  ";
		  cin>>value;
		  printf(" Voici la liste des multiples de %d :\n",value);
		  while(ptr!=NULL)
			  {
			  if(ptr->field%value==0)
				 {
				 printf("%4d",ptr->field);
				 k++;
				 }
				 ptr=ptr->link;
				 }
		  if(k==0)
				  {
				  printf(" La liste ne renferme pas des multiples de %d.",value);
				  }

		}
	 }






	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui supprime toutes les occurrences     */
	 /*                        d'un élément de la liste                        */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void remove_all_the_value_occ()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  int k=0;
	  int value;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Saisissez l\'enttier dont vous souhaitez supprimer les occurrences : ";
		  cin>>value;
		  while(ptr!=NULL)
			  {
				if(ptr->field!=value)
				 {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field;
				 p->link=pp;
				 pp=p;
				 k++;
				 }
				 ptr=ptr->link;
				 head=pp;
			 }

			  cout<<" Suppression de toutes les occurrences de :"<<value<<"\n";
			  display();


		}
	 }






	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui crée la liste miroir  de la         */
	 /*                        liste saisie                                    */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void invert_my_linked_list()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field;
				 p->link=pp;
				 pp=p;
				 ptr=ptr->link;
				 }
				 head=pp;
			 }

			  cout<<" Liste miroir :\n";
			  display();


		}






	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui se charge de la multiplication      */
	 /*                        de tous les éléments                            */
	 /*                     de la liste par un entier                          */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void multiply_my_linked_list_elements()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  int number;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Multiplication fois quel entier ? :  ";endl;
		  cin>>number;
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field*number;
				 p->link=pp;
				 pp=p;
				 ptr=ptr->link;
				 }
				 head=pp;
			 }

			  cout<<" Après multiplication des éléments par "<<number;endl;
			  invert_my_linked_list();   // on inverse le résultat car la liste est inversée


		}





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui se charge de la division            */
	 /*                        de tous les éléments                            */
	 /*                     de la liste par un entier                          */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void divide_my_linked_list_elements()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  int number;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  do
		  {
		  cout<<" Division sur quel entier ? :  ";endl;
		  cin>>number;
		  }while(number==0);  // on évite la division par 0
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field/number;
				 p->link=pp;
				 pp=p;
				 ptr=ptr->link;
				 }
				 head=pp;
			 }

			  cout<<" Division entière des éléments par "<<number;endl;
			  invert_my_linked_list();   // on inverse le résultat car la liste est inversée

		}





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui se charge de l'addition             */
	 /*                        d'un entier à tous les élments                  */
	 /*                                   de la liste                          */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void add_an_integer_to_my_linked_list_elements()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  int number;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Additionner quel entier aux éléments de la liste ?  : ";endl;
		  cin>>number;
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field+number;
				 p->link=pp;
				 pp=p;
				 ptr=ptr->link;
				 }
				 head=pp;
			 }

			  cout<<" Addition de "<<number<<" aux éléments de la liste ";endl;
			  invert_my_linked_list();   // on inverse le résultat car la liste est inversée

		}




	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui se charge de la soustraction        */
	 /*                        d'un entier à tous les élments                  */
	 /*                                   de la liste                          */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void minus_an_integer_from_my_linked_list_elements()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  int number;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Soustraire quel entier aux éléments de la liste ?  : ";endl;
		  cin>>number;
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 p->field=ptr->field-number;
				 p->link=pp;
				 pp=p;
				 ptr=ptr->link;
				 }
				 head=pp;
			 }

			  cout<<" Soustraction de"<<number<<" aux éléments de la liste ";endl;
			  invert_my_linked_list();   // on inverse le résultat car la liste est inversée

		}




	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui se charge de la soustraction        */
	 /*                        d'un entier à un élément donné                  */
	 /*                                   de la liste                          */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void minus_an_integer_from_given_linked_list_element()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  int number;
	  int value;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Soustraire quel entier ?  : ";endl;
		  cin>>number;
		  cout<<" De quel élément de la liste ? :";endl;
		  cin>>value;
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 if(ptr->field==value)
					{
					 p->field=ptr->field-number;
					 p->link=pp;
					 pp=p;
					 ptr=ptr->link;
					}else
					  {
						p->field=ptr->field;
						p->link=pp;
						pp=p;
						ptr=ptr->link;
					  }
				  }
				 head=pp;
				 cout<<" Après soustraction de "<<number<<" à toutes les occurrences de "<<value<< ":";endl;
				 invert_my_linked_list();   // on inverse le résultat car la liste est inversée

			  }

		}





	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui se charge de l'addition             */
	 /*                        d'un entier à un élément donné                  */
	 /*                                   de la liste                          */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void add_an_integer_for_given_linked_list_element()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  int number;
	  int value;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Additionner quel entier  ?  : ";endl;
		  cin>>number;
		  cout<<" Pour quel élément de la liste ? :";endl;
		  cin>>value;
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 if(ptr->field==value)
					{
					 p->field=ptr->field+number;
					 p->link=pp;
					 pp=p;
					 ptr=ptr->link;
					}else
					  {
						p->field=ptr->field;
						p->link=pp;
						pp=p;
						ptr=ptr->link;
					  }
				  }
				 head=pp;
				 cout<<" Après addition de "<<number<<" à toutes les occurrences de "<<value<< ":";endl;
				 invert_my_linked_list();   // on inverse le résultat car la liste est inversée

			  }

		}




	 /*  ********************************************************************* */
	 /*                                                                        */
	 /* Implémentation de la procédure qui se charge de l'addition             */
	 /*                        d'un entier à un élément donné                  */
	 /*                                   de la liste                          */
	 /*                                                                        */
	 /* ********************************************************************** */
	 void multiply_an_integer_by_given_linked_list_element()
	 {
	  cell*p=NULL;
	  cell*pp=NULL;
	  cell*ptr=head;
	  int number;
	  int value;
	  if(ptr==NULL)
		{
		cout<<" La liste est vide.";
		}else
		  {
		  cout<<" Multiplier par quel entier  ?  : ";endl;
		  cin>>number;
		  cout<<" Pour quel élément de la liste ? :";endl;
		  cin>>value;
		  while(ptr!=NULL)
			  {
				 p=(cell*)malloc(sizeof(cell));
				 if(ptr->field==value)
					{
					 p->field=ptr->field*number;
					 p->link=pp;
					 pp=p;
					 ptr=ptr->link;
					}else
					  {
						p->field=ptr->field;
						p->link=pp;
						pp=p;
						ptr=ptr->link;
					  }
				  }
				 head=pp;
				 cout<<" Après multiplication de "<<number<<" fois toutes les occurrences de "<<value<< ":";endl;
				 invert_my_linked_list();   // on inverse le résultat car la liste est inversée

			  }

		}