Université Moulay Ismaïl 2021-2022

ENSAM – Meknès 2 Année

ème

Programmation avancée en C++

Corrigé du TD2 - Listes chaînées

A- Listes chaînées simples

Exercice 1

#include<iostream>
using namespace std;
typedef int TypElem;
struct noeud{
TypElem val ;
noeud * suivant ;
} ;
typedef struct noeud* listechainee;
listechainee insereFin(listechainee L, TypElem donnee){
listechainee p, nouveau;
nouveau = new noeud;
nouveau->val = donnee;
nouveau->suivant = NULL;
if (L==NULL)
L=nouveau;
else {
for (p=L ; p->suivant!=NULL ; p=p->suivant);
p->suivant = nouveau;
}
return L;
}
listechainee lireListe(){
char choix;
TypElem donnee;
listechainee L=NULL; /* initialisation obligatoire ! */
cout<<"Voulez-vous entrer une liste non vide ? ";
cin>>choix;
while (choix=='o'||choix=='O'){
cout<<"Entrez une donnee : ";
cin>>donnee;
cin.clear(); // vider le tampon
L=insereFin(L,donnee);
cout<<"Voulez-vous continuer (o/n)? : ";
cin>>choix;
cin.clear();
}
return L;
}
int tailleListeIter(listechainee L){
int t=0;
while (L){
t++;
L=L->suivant;
}
return t;
}
__________________________________________________________________________________________
A. Ahmadi 1/16 ENSAM-Meknès
 int tailleListeRec(listechainee L){
if(L)
return 1+tailleListeRec(L->suivant);
else
return 0;
}
void detruireListe(listechainee*adrL) { //passage d’un pointeur par adresse :
listechainee p;
while (*adrL != NULL){
p = *adrL;
*adrL = (*adrL)->suivant;
delete p;
}
*adrL = NULL; // on réinitialise la liste à vide
}
void afficheListe(listechainee L){
if(L){
cout<<L->val<<" ";
afficheListe(L->suivant);
}
}
main(){
TypElem x0;
listechainee L1=NULL;
L1=lireListe();
cout<<"Voici les elements de la liste :"<<endl;
afficheListe(L1);
cout<<"\nLa taille de la liste L1 (fct recursive) est : "<<tailleListeRec(L1);
cout<<"\nLa taille de la liste L1 (fct iterative) est : "<<tailleListeIter(L1);
detruireListe(&L1);
}

Exercice 2

… // Mettre les mêmes déclarations et les fonctions lireListe, insereFin,

// afficheListe et detruireListe de l’exercice 1.
TypElem maxi(int a,int b){
return (a>b)?a:b;
}
TypElem maxListe( listechainee L){
if (L->suivant==NULL) return L->val;
else return maxi(L->val,maxListe(L->suivant));
}
TypElem sommeListe( listechainee L){
if(L) return L->val+sommeListe(L->suivant);
else return 0;
}
main(){
TypElem x0;
listechainee L1=NULL;
L1=lireListe();
cout<<"Voici les elements de la liste :"<<endl;
afficheListe(L1);
cout<<"\nLa somme des elements de la liste L1 est : "<<sommeListe(L1);
if (L1)
cout<<"\nLa Le maximum des elemnts de la liste L1 est : "<<maxListe(L1);
else
cout<<"\nPas de maximum, la liste est vide !\n";
detruireListe(&L1);
}

__________________________________________________________________________________________
A. Ahmadi 2/16 ENSAM-Meknès
Exercice 3

… // Mettre les mêmes déclarations et les fonctions lireListe, insereFin,

// afficheListe et detruireListe de l’exercice 1.
typedef char TypElem[21]; //peElem est une chaine de caractères de taille max=20
int occurrElemListe (listechainee L,TypElem ch){
int nb=0;
while(L){
if(strcmp(L->val,ch)==0)
nb++;
L=L->suivant;
}
return nb;
}
main(){
TypElem ch1;
cin.clear();
listechainee L1=NULL;
L1=lireListe();
cout<<"Voici les elements de la liste :"<<endl;
afficheListe(L1);
cout<<"\nDonner la chaine a rechercher : ";
cin.sync(); // Vider le tampon
cin.clear();
cin.getline(ch1,20);
cout<<"Le nombre d'occurrences de "<<ch1<<" est : "<<occurrElemListe(L1,ch1);
detruireListe(&L1);
}

Exercice 4

… // Mettre les mêmes déclarations et les fonctions lireListe, insereFin,

// afficheListe et detruireListe de l’exercice 1.
void suppPosListe(listechainee* L, int pos){
listechainee temp = *L;
listechainee precedent = NULL;
int p;
if (temp != NULL && pos==1){
*L = temp->suivant;
delete temp;
return;
}
else{
p=1;
while (temp != NULL && p<pos){
precedent = temp;
temp = temp->suivant;
p++;
}
// si l'element ne se trouve pas dans la liste
if (temp == NULL){
cout<<"Position invalide !\n";
return;
}
// retirer les liens du noeud avec la liste et le libérer
precedent->suivant = temp->suivant;
delete temp;
}
}

__________________________________________________________________________________________
A. Ahmadi 3/16 ENSAM-Meknès
 void suppElemListe(listechainee* L, TypElem donnee){
listechainee temp = *L;
listechainee precedent = NULL;
if (temp != NULL && temp->val == donnee){
*L = temp->suivant;
delete temp;
return;
}
else{
while (temp != NULL && temp->val != donnee){
precedent = temp;
temp = temp->suivant;
}
// si l'element ne se trouve pas dans la liste
if (temp == NULL)
return;
// retirer les liens du noeud avec la liste et le libérer
precedent->suivant = temp->suivant;
delete temp;
}
}

main(){
TypElem x0;
int position;
listechainee L1=NULL;
L1=lireListe();
cout<<"Voici les elements de la liste :"<<endl;
afficheListe(L1);
do {
cout<<"\nDonner la position (>=1) de l'element a supprimer : ";
cin>>position;
}while (position<1);
suppPosListe(&L1,position);
cout<<"Voici le nouveau contenu de la liste :"<<endl;
afficheListe(L1);
cout<<"\nDonner la valeur de l'element a supprimer : ";
cin>>x0;
suppElemListe(&L1,x0) ;
cout<<"Voici le nouveau contenu de la liste :"<<endl;
afficheListe(L1);
detruireListe(&L1);
}

Exercice 5

… // Mettre les mêmes déclarations et les fonctions lireListe, insereFin,

// afficheListe et detruireListe de l’exercice 1.
void inverseListe(listechainee *L){
listechainee courant = *L;
listechainee prec = NULL, suiv = NULL;
while (courant != NULL) {
// sauvegarder le noeud suivant
suiv = courant->suivant;
// Inverser le pointeur du noeud courant
courant->suivant = prec;
// Déplacer les pointeurs d'une position vers l'avant.
prec = courant;
courant = suiv;
}
*L = prec;
}

__________________________________________________________________________________________
A. Ahmadi 4/16 ENSAM-Meknès
 main(){
listechainee L1=NULL;
L1=lireListe();
cout<<"Voici les elements de la liste :"<<endl;
afficheListe(L1);
inverseListe(&L1);
cout<<"\Voici liste apres son inversion :"<<endl;
afficheListe(L1);
detruireListe(&L1);
}

Exercice 6

… // Mettre les mêmes déclarations et les fonctions lireListe, insereFin,

// afficheListe et detruireListe de l’exercice 1.
void concatListes(listechainee *Liste1, listechainee Liste2 ){
//Passage de Liste1 par adresse et Liste2 par valeur
listechainee ptr;
ptr = *Liste1;
while(ptr->suivant != NULL)
ptr = ptr->suivant ;
ptr->suivant = Liste2 ;
}
main(){
listechainee L1=NULL,L2=NULL;
cout<<"Saisir les elements de la 1ere liste :\n";
L1=lireListe();
cout<<"\nSaisir les elements de la 2eme liste :\n";
L2=lireListe();
cout<<"Voici les elements de la 1ere liste :\n";
afficheListe(L1);
cout<<"\nVoici les elements de la 2eme liste :\n";
afficheListe(L2);
concatListes(&L1,L2); //Passage de L1 par adresse et L2 par valeur
cout<<"\nVoici leur concatenation :\n";
afficheListe(L1);
detruireListe(&L1);
}

Exercice 7

… // Mettre les mêmes déclarations et les fonctions lireListe, insereFin,

// afficheListe et detruireListe de l’exercice 1.
void lireTab(TypElem T[],int n){
int i;
for (i=0;i<n;i++){
cout<<"\tElement ["<<i<<"]: ";
cin>>T[i];
}
}
void afficheTab(TypElem T[],int n){
int i;
for (i=0;i<n;i++){
cout<<T[i]<<" ";
}
}

__________________________________________________________________________________________
A. Ahmadi 5/16 ENSAM-Meknès
 listechainee listeDuTableau(TypElem T[], int n){
int i;
TypElem donnee;
listechainee L = NULL;
for (i = 0; i < n; i++)
L = insereFin(L, T[i]);
return L;
}

TypElem* tableauDeListe(listechainee L, int *n){ // Noter le passage par adresse de n

int i=0;
TypElem *T;
listechainee ptr;
ptr = L;
*n = 0; // Nombre d'elements dans la liste
while (ptr != NULL){
(*n)++;
ptr = ptr->suivant;
}
T=(TypElem*) new (nothrow) TypElem[*n];
ptr = L; //retour au début de la liste
while (ptr != NULL){
T[i] = ptr->val;
ptr = ptr->suivant;
i++;
}
return T;
}

main(){
listechainee L1=NULL;
TypElem T1[50];
int taille1;
cout<<"\nDonner la taille du tableau : ";
cin>>taille1;
lireTab(T1,taille1);
L1=listeDuTableau(T1,taille1);
cout<<"\nVoici les elements de la liste construite a partir du tableau :\n";
afficheListe(L1);
//--------------------------------------------------------------------------
listechainee L2=NULL;
TypElem *T2;
int taille2;
L2=lireListe();
T2=tableauDeListe(L2,&taille2); // Noter le passage par adresse de la taille
cout<<"\nVoici les elements du tableau construit a partir de la liste :\n";
afficheTab(T2,taille2);
detruireListe(&L1);
}

__________________________________________________________________________________________
A. Ahmadi 6/16 ENSAM-Meknès
Exercice 8

… // Mettre les mêmes déclarations et les fonctions lireListe, insereFin,

// afficheListe et detruireListe de l’exercice 1.
void triListe(listechainee L){ // ici les noeud ne changent pas, mais c'est leurs valeurs qui peuvent être permutées
int aux;

struct noeud *ptr, *temp;

ptr = L;
while(ptr->suivant != NULL){
temp = ptr->suivant;
while(temp != NULL){
if(ptr->val > temp->val){
aux = ptr->val;
ptr->val = temp->val;
temp->val = aux;
}
temp = temp->suivant;
}
ptr = ptr->suivant;
}
}

main(){
listechainee L1=NULL;
L1=lireListe();
cout<<"Voici les elements de la 1ere liste :\n";
afficheListe(L1);
triListe(L1);
cout<<"\nVoici la liste triee :\n";
afficheListe(L1);
detruireListe(&L1);
}

Exercice 9

#include<iostream>
#include<cstring>
using namespace std;
struct noeud{
int num;
char nom[21];
float moy;
noeud * suivant ;
} ;
typedef struct noeud* listechainee;
listechainee insereFin(listechainee L, int num1,char nom1[21],float moy1){
listechainee p, nouveau;
nouveau = new noeud;
nouveau->num = num1;
strcpy(nouveau->nom,nom1); // #include<cstring>
nouveau->moy = moy1;
nouveau->suivant = NULL;
if (L==NULL)
L=nouveau;
else {
for (p=L ; p->suivant!=NULL ; p=p->suivant);
p->suivant = nouveau;
}
return L;
}

__________________________________________________________________________________________
A. Ahmadi 7/16 ENSAM-Meknès
 listechainee lireListeEtud(){
char choix;
int NUMERO;
char NOM[21];
float MOY;
listechainee L=NULL; // initialisation obligatoire !
cout<<"Voulez-vous entrer une liste d'etudiants non vide ? ";
cin>>choix;
while (choix=='o'||choix=='O'){
cout<<"Donnez le numero de l'etudiant : ";
cin>>NUMERO;
cin.sync(); cin.clear(); // vider le tampon
cout<<"Donnez le nom de l'etudiant : ";
cin>>NOM;
cout<<"Donnez la moyenne de l'etudiant : ";
cin>>MOY;
L=insereFin(L,NUMERO,NOM,MOY);
cout<<"Voulez-vous continuer (o/n)? : ";
cin>>choix;
cin.clear();
}
return L;
}
void detruireListeEtud(listechainee*adrL) { //passage d’un pointeur par adresse :
listechainee p;
while (*adrL != NULL){
p = *adrL;
*adrL = (*adrL)->suivant;
delete p;
}
*adrL = NULL; // on réinitialise la liste à vide
}
void afficheListeEtud(listechainee L){
if(L){
cout<<"{"<<L->num<<","<<L->nom<<","<<L->moy<<"} ";
afficheListeEtud(L->suivant);
}
}
void triListeEtud(listechainee L){ // ici les noeud ne changent pas, mais c'est leurs valeurs qui peuvent être permutées
int auxNum;
char auxNom[21];
float auxMoy;
struct noeud *ptr, *temp;
ptr = L;
while(ptr->suivant != NULL){
temp = ptr->suivant;
while(temp != NULL){
if(ptr->moy < temp->moy){
auxNum = ptr->num;
ptr->num = temp->num;
temp->num = auxNum;
strcpy(auxNom, ptr->nom);
strcpy(ptr->nom, temp->nom);
strcpy(temp->nom, auxNom);
auxMoy = ptr->moy;
ptr->moy = temp->moy;
temp->moy = auxMoy;
}
temp = temp->suivant;
}
ptr = ptr->suivant;
}
}
__________________________________________________________________________________________
A. Ahmadi 8/16 ENSAM-Meknès
 main(){
listechainee L1=NULL;
L1=lireListeEtud();
cout<<"Voici les elements de la liste :\n";
afficheListeEtud(L1);
triListeEtud(L1);
cout<<"\nVoici la liste d'etudiants triee par ordre decroissant de leurs moyennes :\n";
afficheListeEtud(L1);
detruireListeEtud(&L1);
}

__________________________________________________________________________________________
A. Ahmadi 9/16 ENSAM-Meknès
Exercice 10
#include<iostream>
using namespace std;
typedef int TypElem;

struct noeud{
TypElem val ;
noeud * suivant ;
} ;

noeud* insereListeVide(noeud *dernier, TypElem donnee){

if (dernier != NULL)
return dernier;
noeud *nouveau =new noeud;
nouveau -> val = donnee;
dernier = nouveau;
nouveau -> suivant = dernier;
return dernier;
}

noeud *insereListeFin(noeud *dernier, TypElem donnee){

if (dernier == NULL)
return insereListeVide(dernier, donnee);
noeud *nouveau =new noeud;
nouveau -> val = donnee;
nouveau -> suivant = dernier -> suivant;
dernier -> suivant = nouveau;
dernier = nouveau;
return dernier;
}

noeud * lireListeCirc(){
char choix;
TypElem donnee;
noeud * L=NULL; /* initialisation obligatoire ! */
cout<<"Voulez-vous entrer une liste non vide ? ";
cin>>choix;
while (choix=='o'||choix=='O'){
cout<<"Entrez une donnee : ";
cin>>donnee;
cin.clear(); // vider le tampon
L=insereListeFin(L,donnee);
cout<<"Voulez-vous continuer (o/n)? : ";
cin>>choix;
cin.clear();
}
return L;
}

void afficherListeCirc(noeud *dernier){

noeud *p;
if (dernier == NULL) {
cout << "Liste vide." << endl;
return;
}
p = dernier -> suivant;
do {
cout << p -> val << " ";
p = p -> suivant;
}
while(p != dernier->suivant);
}

__________________________________________________________________________________________
A. Ahmadi 10/16 ENSAM-Meknès
 int tailleListeCirc(noeud *dernier){
noeud *p;
p=dernier;
int s=0;
if (p!=NULL){
do{
p=p->suivant;
s++;
}while (p != dernier);
}
return s;
}

main(){
noeud *Lc1 = NULL, *Lc2=NULL;
TypElem x0;

Lc1 = insereListeVide(Lc1, 3); Lc1 = insereListeFin(Lc1, 20);

Lc1 = insereListeFin(Lc1, 16); Lc1 = insereListeFin(Lc1, 20);
Lc1 = insereListeFin(Lc1, 11);
cout<<"Voici les elements de la 1ere liste circulaire :\n";
afficherListeCirc(Lc1);
cout<<"\nLa taille de la 1ere liste est : "<<tailleListeCirc(Lc1)<<endl;
Lc2=lireListeCirc();
cout<<"Voici les elements de la 2eme liste circulaire :\n";
afficherListeCirc(Lc2);
cout<<"\nLa taille de la 2eme liste est : "<<tailleListeCirc(Lc2)<<endl;
}

Exercice11

#include<iostream>
using namespace std;

typedef int TypElem;

struct noeud{
TypElem val ;
noeud * suivant ;
} ;

noeud* insereListeVide(noeud *dernier, TypElem donnee){

if (dernier != NULL)
return dernier;
noeud *nouveau =new noeud;
nouveau -> val = donnee;
dernier = nouveau;
nouveau -> suivant = dernier;
return dernier;
}

noeud *insereListeFin(noeud *dernier, TypElem donnee){

if (dernier == NULL)
return insereListeVide(dernier, donnee);
noeud *nouveau =new noeud;
nouveau -> val = donnee;
nouveau -> suivant = dernier -> suivant;
dernier -> suivant = nouveau;
dernier = nouveau;
return dernier;
}

__________________________________________________________________________________________
A. Ahmadi 11/16 ENSAM-Meknès
 void parcourtListe(noeud *dernier){
noeud *p;
if (dernier == NULL) {
cout << "Liste vide." << endl;
return;
}
cout<<"voici les elements de la liste circulaire:\n";
p = dernier -> suivant;
do {
cout << p -> val << " ";
p = p -> suivant;
}
while(p != dernier->suivant);

bool estListeCirc(noeud *L){

if (L == NULL)
return true;
noeud* temp = L->suivant;
while (temp != NULL && temp != L)
temp = temp->suivant;
return (temp == L);
}

main(){
noeud *Lc1 = NULL, *Lc2=NULL;
noeud e1;
e1.val=1111;
e1.suivant=NULL;
Lc2=&e1;
Lc1 = insereListeFin(Lc1, 3); Lc1 = insereListeFin(Lc1, 8);
Lc1 = insereListeFin(Lc1, 5); Lc1 = insereListeFin(Lc1, 20);
Lc1 = insereListeFin(Lc1, 16); Lc1 = insereListeFin(Lc1, 99);
parcourtListe(Lc1);
cout<<endl;
if (estListeCirc(Lc1))
cout<<"Lc1 est circulaire";
else
cout<<"Lc1 n'est pas circulaire";
if (estListeCirc(Lc2))
cout<<"\nLc2 est circulaire";
else
cout<<"\nLc2 n'est pas circulaire";
}

__________________________________________________________________________________________
A. Ahmadi 12/16 ENSAM-Meknès
Exercice12
#include<iostream>
using namespace std;

typedef int TypElem;

struct noeud{
TypElem val ;
noeud * suivant ;
} ;

noeud * insereFinListeSimple(noeud * l, TypElem donnee){

noeud * p,*nouveau;
nouveau = new noeud;
nouveau->val = donnee;
nouveau->suivant = NULL;
if (l==NULL)
l=nouveau;
else {
// recherche de la dernière cellule
for (p=l ; p->suivant!=NULL ; p=p->suivant);
p->suivant = nouveau;
}
return l;
}

void afficheListeSimple(noeud * L){

while(L){
cout<<L->val<<" ";
L=L->suivant;
}
}

void afficherListeCirc(noeud *dernier){

noeud *p;
if (dernier == NULL) {
cout << "Liste vide." << endl;
return;
}
p = dernier -> suivant;
do {
cout << p -> val << " ";
p = p -> suivant;
}
while(p != dernier->suivant);

noeud* convertSimpCirc(noeud* L){

noeud* dernier=L;
while (dernier->suivant != NULL)
dernier = dernier->suivant;
dernier->suivant = L;
cout<<"La liste simple a ete convertie en une liste circulaire";
return dernier;
}

noeud * convertCircSimp(noeud* Lc){ // Lc=dernier élément de la liste circulaire

noeud *L=Lc->suivant;
Lc->suivant=NULL;
cout<<"\nLa liste circulaire a ete convertie en une liste simple";
return L;
}

__________________________________________________________________________________________
A. Ahmadi 13/16 ENSAM-Meknès
 main(){
noeud *L1 = NULL;
L1 = insereFinListeSimple(L1, 11); L1 = insereFinListeSimple(L1, 22);
L1 = insereFinListeSimple(L1, 33); L1 = insereFinListeSimple(L1, 44);
L1 = insereFinListeSimple(L1, 55);
L1=convertSimpCirc(L1);
cout<<"\nVoici les elements de la nouvelle liste circulaire :\n";
afficherListeCirc(L1);
// Convertissons de nouveau L1 en une liste circulaire
L1=convertCircSimp(L1);
L1=insereFinListeSimple(L1,66);
cout<<"\nVoici les elements de la nouvelle liste simple apres ajout de 66 :\n";
afficheListeSimple(L1);
}

Exercice 13

#include<iostream>
using namespace std;
typedef int TypeElem;
struct noeud{ // noeud de la liste chaînée simple
TypeElem val ;
noeud * suivant ;
} ;
struct noeudDble { // noeud de la liste doublement chaînée
TypeElem val;
struct noeudDble* suivant;
struct noeudDble* precedent;
};
noeud * insereFinListeSimple(noeud * l, TypeElem donnee){
noeud * p,*nouveau;
nouveau = new noeud;
nouveau->val = donnee;
nouveau->suivant = NULL;
if (l==NULL)
l=nouveau;
else {
// recherche du dernier noeud
for (p=l ; p->suivant!=NULL ; p=p->suivant);
p->suivant = nouveau;
}
return l;
}
void insereFinListDblCh(struct noeudDble** L, TypeElem donnee) {
struct noeudDble* nouveau = new noeudDble;
nouveau->val = donnee;
nouveau->suivant = NULL;
struct noeudDble* temp = *L;
if (*L == NULL) {
nouveau->precedent = NULL;
*L = nouveau;
return;
}
while (temp->suivant != NULL)
temp = temp->suivant;
temp->suivant = nouveau;
nouveau->precedent = temp;
}

noeudDble* convertSimpDouble(noeud * L) {
__________________________________________________________________________________________
noeudDble* Ldc=NULL;
A. Ahmadi 14/16 ENSAM-Meknès
noeudDble* nouv;
while(L){
insereFinListDblCh(&Ldc,L->val);
L=L->suivant;
 noeudDble* convertSimpDouble(noeud * L) {
noeudDble* Ldc=NULL;
noeudDble* nouv;
while(L){
insereFinListDblCh(&Ldc,L->val);
L=L->suivant;
}
return Ldc;
}

void afficheListeSimple(noeud * L){

while(L){
cout<<L->val<<" ";
L=L->suivant;
}
}

void afficheListeDble(noeudDble* L) {
while (L != NULL) {
cout << L->val << " -> ";
L = L->suivant;
}
cout<<"NULL";
}

int main() {
noeud* L1 = NULL;
noeudDble* Ldc1=NULL;
L1=insereFinListeSimple(L1, 15);
L1=insereFinListeSimple(L1, 25);
L1=insereFinListeSimple(L1, 35);
L1=insereFinListeSimple(L1, 45);
L1=insereFinListeSimple(L1, 55);
L1=insereFinListeSimple(L1, 65);
cout<<"Voici les element de la liste chainee simple L1 :\n";
afficheListeSimple(L1);
Ldc1=convertSimpDouble(L1);
cout<<"\n\nVoici les element de la liste simple Ldc1 (conversion de L1) :\n";
afficheListeDble(Ldc1);
cout<<"\n\nnLa valeur du 2eme element de la liste doublement chainee Lcd1 est: ";
cout<<Ldc1->suivant->suivant->precedent->val<<endl;
}

__________________________________________________________________________________________
A. Ahmadi 15/16 ENSAM-Meknès
Exercice 14

#include<iostream>
using namespace std;
typedef int TypeElem;
struct noeudDble {
TypeElem val;
struct noeudDble* suivant;
struct noeudDble* precedent;
};

void insereFinListDblCh(struct noeudDble** L, TypeElem donnee) {

struct noeudDble* nouveau = new noeudDble;
nouveau->val = donnee;
nouveau->suivant = NULL;
struct noeudDble* temp = *L;
if (*L == NULL) {
nouveau->precedent = NULL;
*L = nouveau;
return;
}
while (temp->suivant != NULL)
temp = temp->suivant;
temp->suivant = nouveau;
nouveau->precedent = temp;
}

void afficheListeDble(noeudDble* L) {
while (L != NULL) {
cout << L->val << " -> ";
L = L->suivant;
}
cout<<"NULL";
}

noeudDble* adrElemListeDc (noeudDble* Ldc, int pos){

int i=1;
if (pos<=0)
return NULL;
while((i<pos)&&(Ldc!=NULL)){
Ldc =Ldc->suivant;
i++;
}
return Ldc;
}

int main() {
noeudDble* Ldc1=NULL;
insereFinListDblCh(&Ldc1, 15);insereFinListDblCh(&Ldc1, 25);insereFinListDblCh(&Ldc1, 35);
insereFinListDblCh(&Ldc1, 45); insereFinListDblCh(&Ldc1, 55);insereFinListDblCh(&Ldc1, 65);
cout<<"Voici les element de la liste simple Ldc1 :\n";
afficheListeDble(Ldc1);
cout<<"\nLdc1="<<Ldc1;
cout<<"\nL'adresse du noeud a la position 1 de Ldc1 est : "<<adrElemListeDc(Ldc1,1);
cout<<"\nL'adresse du noeud a la position 2 de Ldc1 est : "<<adrElemListeDc(Ldc1,2);
cout<<"\nL'adresse du noeud a la position 3 de Ldc1 est : "<<adrElemListeDc(Ldc1,3);
cout<<"\nL'adresse du noeud a la position 6 de Ldc1 est : "<<adrElemListeDc(Ldc1,6);
cout<<"\nL'adresse du noeud a la position 7 de Ldc1 est : "<<adrElemListeDc(Ldc1,7);
cout<<"\nL'adresse du noeud a la position 8 de Ldc1 est : "<<adrElemListeDc(Ldc1,8);
cout<<"\nL'adresse du noeud a la position -2 de Ldc1 est : "<<adrElemListeDc(Ldc1,-2);
cout<<"\nL'adresse du noeud a la position 1 de NULL est : "<<adrElemListeDc(NULL,1);
cout<<endl;
}

__________________________________________________________________________________________
A. Ahmadi 16/16 ENSAM-Meknès