一个简单的双向链表

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

struct SDblLNode

{
int iDta;
SDblLNode* pPre;
SDblLNode* pNext;

};//链表数据

class CDblLink

{

public:
CDblLink();
virtual ~CDblLink();

bool push( int iDta );
bool Delete( int iDta );

void Show( bool bForward = false );

private:
SDblLNode* m_pHead;

};

CDblLink::CDblLink()

{
m_pHead = NULL;

}

CDblLink::~CDblLink()

{
if( m_pHead )
{
free( m_pHead );
m_pHead = NULL;
}

}

bool CDblLink::push( int iDta )

{
SDblLNode* pNode = (SDblLNode*)malloc( sizeof( SDblLNode ) );
if( !pNode )
{
return false;
}
pNode->iDta = iDta;
pNode->pNext = pNode->pPre = NULL;

if( !m_pHead )
{
m_pHead = pNode;
m_pHead->pPre = m_pHead->pNext = m_pHead;
return true;
}

m_pHead->pPre->pNext = pNode;
pNode->pNext = m_pHead;

pNode->pPre = m_pHead->pPre;
m_pHead->pPre = pNode;

return true;

}

bool CDblLink::Delete( int iDta )

{
if( !m_pHead )
{
return false;
}

if( m_pHead->iDta == iDta )
{
m_pHead->pNext->pPre = m_pHead->pPre;
m_pHead->pPre->pNext = m_pHead->pNext;
return true;
}

SDblLNode* pCur = m_pHead;

while( pCur->pNext != m_pHead  )
{
if( pCur->iDta == iDta )
{
break ;
}
pCur = pCur->pNext;
}

if( pCur == m_pHead )
{
return false;
}

pCur->pNext->pPre = pCur->pPre;
pCur->pPre->pNext = pCur->pNext;

free ( pCur );
pCur = NULL;

}

void CDblLink::Show( bool bForward/* = false*/ )

{
SDblLNode* pCur = m_pHead;

if( bForward )
{
pCur = pCur->pPre;
}
else
{
printf( "%d\t", pCur->iDta );
pCur = pCur->pNext;
}

while( pCur != m_pHead )
{
printf( "%d\t", pCur->iDta );

bForward ? pCur = pCur->pPre : pCur = pCur->pNext; 
}

if( bForward )
{
printf( "%d\t", m_pHead->iDta );
}
}

int main(int argc, char* argv[])

{

CDblLink list;

for( int i = 0; i < 100; ++i )
{
list.push( i );
}

printf("Init:\n");
printf("\nForward:\n");
list.Show( true );
printf("\nBackward\n");
list.Show( false );

for( i = 10; i < 50; ++i )
{
list.Delete( i );
}

printf("\ndelete 10~50:\n");
printf("\nForward:\n");
list.Show( true );
printf("\nBackward\n");
list.Show( false );

return 0;

}