利用c++模板实现单链表

/* SList.hpp */

#ifndef _SLIST_H_
#define _SLIST_H_

#include <iostream>

using namespace std;

template<typename T>
struct Node
{
T m_Data;
Node<T> *m_pNext;
Node()
{
m_pNext = NULL;
}
};

template<typename T>
class CSList
{
public:
CSList();
~CSList();
//尾插法
bool AppendNode(T Data);
//删除
bool DelNode(T key);
//修改
bool ModNode(T key, T New);
//查找
bool FindNode(T key);
//逆序
bool Reverse();
//打印
void Print();
//销毁
void Clear();
private:
Node<T> *m_pFirst;
};

template<typename T>
CSList<T>::CSList()
{
m_pFirst = NULL;
}

template<typename T>
CSList<T>::~CSList()
{
Node<T> *pCurNode = NULL;
pCurNode = m_pFirst;
while(pCurNode)
{
m_pFirst = m_pFirst->m_pNext;
delete pCurNode;
pCurNode = m_pFirst;
}
}

template<typename T>
bool CSList<T>::AppendNode(T Data)
{
Node<T> *pNewNode = new Node<T>;
Node<T> *pCurNode = NULL;
if(!pNewNode)
{
return false;
}
pNewNode->m_Data = Data;
pNewNode->m_pNext = NULL;
if(!m_pFirst)
{
m_pFirst = pNewNode;
return true;
}
pCurNode = m_pFirst;
while(pCurNode->m_pNext)
{
pCurNode = pCurNode->m_pNext;
}
pCurNode->m_pNext = pNewNode;
return true;
}

template<typename T>
bool CSList<T>::DelNode(T Key)
{
Node<T> *pPrevNode = NULL;
Node<T> *pCurNode = NULL;
if(!m_pFirst)
{
return false;
}
if(m_pFirst->m_Data == Key)
{
pCurNode = m_pFirst;
m_pFirst = m_pFirst->m_pNext;
delete pCurNode;
pCurNode = NULL;
return true;
}
pPrevNode = m_pFirst;
pCurNode = m_pFirst->m_pNext;
while(pCurNode->m_Data)
{
if(pCurNode->m_Data == Key)
{
pPrevNode->m_pNext = pCurNode->m_pNext;
delete pCurNode;
return true;
}
pPrevNode = pCurNode;
pCurNode = pCurNode->m_pNext;
}
return false;
}

template<typename T>
bool CSList<T>::ModNode(T key, T New)
{
Node<T> *pCurNode = NULL;
if(!m_pFirst)
{
return false;
}
pCurNode = m_pFirst;
while(pCurNode)
{
if(pCurNode->m_Data == key)
{
pCurNode->m_Data = New;
return true;
}
pCurNode = pCurNode->m_pNext;
}
return false;
}

template<typename T>
bool CSList<T>::FindNode(T key)
{
Node<T> *pCurNode = NULL;
if(!m_pFirst)
{
return false;
}
pCurNode = m_pFirst;
while(pCurNode)
{
if(pCurNode->m_Data == key)
{
return true;
}
pCurNode = pCurNode->m_pNext;
}
return false;
}

template<typename T>
bool CSList<T>::Reverse()
{
Node<T> *pPrevNode = NULL;
Node<T> *pCurNode = m_pFirst;
Node<T> *pNext = NULL;
while(pCurNode)
{
pNext = pCurNode->m_pNext;
pCurNode->m_pNext = pPrevNode;
pPrevNode = pCurNode;
pCurNode = pNext;
}
m_pFirst = pPrevNode;
return true;
}

template<typename T>
void CSList<T>::Print()
{
Node<T> *pCurNode = m_pFirst;
while(pCurNode)
{
cout<<pCurNode->m_Data<<"\t";
pCurNode = pCurNode->m_pNext;
}
cout<<endl;
}

template<typename T>
void CSList<T>::Clear()
{
Node<T> *pCurNode = NULL;
pCurNode = m_pFirst;
while(pCurNode)
{
m_pFirst = m_pFirst->m_pNext;
delete pCurNode;
pCurNode = m_pFirst;
}
}

#endif

/* main.cpp */

#include <iostream>
#include "SList.hpp"

int main()
{
CSList<int> IntList;
IntList.AppendNode(1);
IntList.AppendNode(7);
IntList.AppendNode(4);
IntList.AppendNode(2);
IntList.AppendNode(8);
IntList.AppendNode(5);
IntList.AppendNode(9);
IntList.AppendNode(6);
IntList.AppendNode(3);
IntList.Print();
IntList.Reverse();
IntList.Print();
IntList.DelNode(3);
IntList.DelNode(1);
IntList.DelNode(2);
IntList.Print();
return 0;
}