LISTES DOUBLEMENT CHAÎNÉES

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;
	}
};