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

---

Commentaire sur cette source (11)
Ajouter un commentaire et/ou une note

Programmed by Billal BEGUERADJ
www.begueradj.50megs.com
contact me at : beg.bill@yahoo.com
Bejaia University.

Bonjour tout le monde ;
Mon code présente 40 procédures pour gérer une liste linéaire chaînée.
Ainsi, un grand nombre de problèmes liés à la manipulation des pointeurs sont bien explicités y compris toutes les mises à jour possibles.
Ce code pourrait inspirer à l'utilisation des listes linéaires chaînées comme une alternative à l'organisation des données sous forme de fichiers.
Ce code marche bien sous l'environnement C++ 4.52.
Toute suggestion, remarque ou -pourquoi pas- une erreur commise sont les bienvenus.
Mais si vous télécharger ce code, alors envoyez-moi un e-mail pour me dire 'Tu es un génie':
b.beguer@yahoo.com.
Merci à tous.

	#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<<"Saisisse