Implémentation d'une liste doublement chainée (d'une cellule on peu accéder à la cellule suivante et à la précédente) avec fantome (la première cellule est vide et existe toujours) ce qui facilite l'implémentation.
Il y a deux classe une classe liste et une classe Objet.
les infos de la classe décrivant les cellules (classeObjet) sont ici des entiers (c'est plus simple comme exemple)
Source / Exemple :
class Objet
{
public:
Objet();
virtual ~Objet();
void setSuiv(Objet* s);
Objet* getSuiv();
void setPrec(Objet*);
Objet* getPrec();
void setNb(int val);
int getNb();
private:
int nb;
Objet* suiv;
Objet* prec;
};
Objet::Objet()
{
nb=0;
suiv= NULL;
prec= NULL;
}
Objet::~Objet()
{
}
int Objet::getNb()
{
return nb;
}
void Objet::setNb(int val)
{
nb = val;
}
Objet * Objet::getPrec()
{
return prec;
}
void Objet::setPrec(Objet * p)
{
prec = p;
}
Objet* Objet::getSuiv()
{
return suiv;
}
void Objet::setSuiv(Objet *s)
{
suiv = s;
}
class Liste
{
public:
Liste();
virtual ~Liste();
void add(Objet Obj);
void suppr();
void setCourant(int);
bool existe(Objet); //retourne true sil'objet fait parti de la liste
int getCourant(Objet&); //permet de récupérer les infos de
//l'objet et retourne son indice dans la chaine (de 0 à N)
void precedent();
void suivant();
int nbElts();
private:
int getIndCourant();
Objet* m_courant;
Objet* m_head;
Objet* m_tail;
int nb;
};
Liste::Liste()
{
m_head = new Objet; //création du 'fantome' (ceci facilite l'implémentation
m_courant = m_head;
m_tail = m_head;
nb = 0;
}
Liste::~Liste()
{
}
void Liste::suivant()
{
if(m_courant->getSuiv() != NULL)
m_courant = m_courant->getSuiv();
}
void Liste::precedent()
{
if(m_courant->getPrec()!= m_head)
m_courant = m_courant->getPrec();
}
int Liste::nbElts()
{
return nb;
}
int Liste::getIndm_courant()
{
Objet * ptemp;
ptemp = m_head;
for(int i = -1;ptemp != m_courant;i++,ptemp = ptemp->getSuiv());
//cette boucle for un peu condensé permeet de connaitre l'indice de l'objet
//recherché,on commence à -1 à cause du fantome
//ceci permet aussi de retourné -1 si la liste est vide
return i;
}
int Liste::getm_courant(Objet& Obj)
{
Obj.setNb(m_courant->getNb());
Obj.setPrec(m_courant->getPrec());
Obj.setSuiv(m_courant->getSuiv());
return getIndm_courant(); //on retourne l'indice
}
bool Liste::existe(Objet obj)
{
Objet* ptemp;
ptemp = m_head;
while (ptemp != NULL)
{
ptemp = ptemp->getSuiv();
if (ptemp->getNb() == obj.getNb() )
return true;
}
return false;
}
void Liste::setm_courant(int ind)
{
//permet de changé d'objet courant à partir de son indice
Objet* ptemp;
ptemp = m_head;
for(int i =0;i != ind;i++,ptemp = ptemp->getSuiv());
m_courant = ptemp;
}
void Liste::suppr()
{
if(m_courant != m_head)
{
Objet* ptemp;
ptemp = m_courant;
(ptemp->getPrec())->setSuiv(ptemp->getSuiv());
if(ptemp != m_tail)
(ptemp->getSuiv())->setPrec(ptemp->getPrec());
nb--;
m_courant=ptemp->getPrec();
delete ptemp;
}
}
void Liste::add(Objet Obj)
{
Objet* ptemp;
ptemp = new Objet;
ptemp->setPrec(m_tail);
ptemp->setNb(Obj.getNb());
m_tail->setSuiv(ptemp);
m_tail=ptemp;
nb++;
m_courant=ptemp;
}
Conclusion :
Voila je pensais que ça pouvais etre sympa pour ceux qui souhaitent découvrir les listes chainées.
Dams
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.