Listes doublement chaînées

Commenter

Contenu du snippet

Voilà un morceau de code sur les listes doublement chaînées qui aidera peut-être certaines personnes.

Source / Exemple : 


template<typename T> class CNode
{
    protected :
	T m_Value;
	CNode<T> * m_Previous, * m_Next;

    public :
	CNode( const T & Value = T(), CNode<T> * Previous = NULL, CNode<T> * Next = NULL ) : m_Value(Value), m_Previous(Previous), m_Next(Next) {}

	CNode( const CNode<T> & Node )
	{
		m_Value    = Node.m_Value;
		m_Previous = Node.m_Previous;
		m_Next     = Node.m_Next;
	}

	~CNode() {}

	CNode<T> & CNode<T>::operator = ( const CNode<T> & Node )
	{
		if( m_Previous )
			delete m_Previous;

		if( m_Next )
			delete m_Next;

		m_Value    = Node.m_Value;
		m_Previous = Node.m_Previous;
		m_Next     = Node.m_Next;

		return (*this);
	}

	void SetPrevious( CNode<T> * Previous )
	{
		m_Previous = Previous;
	}

	CNode<T> * GetPrevious() const
	{
		return m_Previous;
	}

	void SetNext( CNode<T> * Next )
	{
		m_Next = Next;
	}

	CNode<T> * GetNext() const
	{
		return m_Next;
	}

	T GetValue() const
	{
		return m_Value;
	}

	void SetValue( const T & Value )
	{
		m_Value = Value;
	}

	bool IsAlone() const
	{
		return !(m_Previous && m_Next);
	}
};

template<typename T> class CLinkedList
{
     private :
	unsigned int m_NbElements;
	CNode<T> * m_Head, * m_Tail;

     public :
	CLinkedList() : m_NbElements(0), m_Head(), m_Tail() {}

	~CLinkedList()
	{
		if( m_Head )
		{
			while( m_NbElements )
				PopBack();

			m_Head = NULL;
			m_Tail = NULL;
		}
	}

	bool IsEmpty() const
	{
		return (m_NbElements == 0);
	}

	CNode<T> * Head() const
	{
		return m_Head;
	}

	CNode<T> * Tail() const
	{
		return m_Tail;
	}

	const unsigned int & NbElements() const
	{
		return m_NbElements;
	}

	void PushBack( const T & Value )
	{
		CNode<T> * Node = new CNode<T>(Value);

		if( !m_Head )
			m_Head = Node;

		Node->SetPrevious(m_Tail);

		if( m_Tail )
			m_Tail->SetNext(Node);

		m_Tail = Node;
		++m_NbElements;
	}

	void PopBack()
	{
		if( m_NbElements > 0 )
		{
			if( m_NbElements == 1 )
				m_Head = NULL;

			CNode<T> * Node = m_Tail;
			m_Tail          = Node->GetPrevious();

			if( m_Tail )
			{
				Node->SetPrevious(NULL);
				m_Tail->SetNext(NULL);
			}
			
			--m_NbElements;
			delete Node;
		}
	}

	void PushFront( const T & Value )
	{
		CNode<T> * Node = new CNode<T>(Value);

		if( !m_Tail )
			m_Tail = Node;

		Node->SetNext(m_Head);

		if( m_Head )
			m_Head->SetPrevious(Node);

		m_Head = Node;
		++m_NbElements;
	}

	void PopFront()
	{
		if( m_NbElements > 0 )
		{
			if( m_NbElements == 1 )
				m_Tail = NULL;

			CNode<T> * Node = m_Head;
			m_Head          = Node->GetNext();

			if( m_Head )
			{
				Node->SetNext(NULL);
				m_Head->SetPrevious(NULL);
			}
			
			--m_NbElements;
			delete Node;
		}
	}

	bool Find( const T & Value )
	{
		CNode<T> * Node = m_Head;

		for( Node = m_Head; Node; Node = Node->GetNext() )
			if( Node->GetValue() == Value )
				return true;

		return false;
	}
};

Conclusion :


Aucun bug connu pour l'instant.

A voir également

S'inscrire maintenant

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.

Du même auteur (nicolas66)