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.
Source / Exemple :
#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
}
}
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.