C++ 实现单链表

#include 
using namespace std;

// 单链表的实现
template
class SingleList
{
public:
	SingleList();
	~SingleList();

private:
	typedef struct tagNode		// 节点定义
	{
		_Ty		_elem;			// 值域
		struct tagNode* pNext;	// 指针域
	}NODE,*PNODE;

	tagNode*	m_pHead;		// 节点头
	tagNode*	m_pTitle;		// 游标		[永远指向的的是最后一个节点]
	int			m_size;			// 链表节点数

public:
	// 在链表尾部追加元素
	bool append(_Ty elem);
	// 在链表任意点插入元素
	bool insert(int pos,_Ty elem);
	// 获取链表头元素
	_Ty front();
	// 获取链表尾部元素
	_Ty last();
	// 获取链表长度
	int length(){return m_size};
	// 删除链表指定节点
	bool deletepos(int pos,_Ty& res);
	// 删除链表所有元素
	bool deleteall();
	// 链表是否为空
	bool empty();
	// 遍历元素
	void traverse();
};

template
SingleList<_Ty>::SingleList()
{
	m_pHead = (tagNode *)malloc(sizeof(tagNode));
	m_pTitle = m_pHead;
	m_size = 0;
}

template
SingleList<_Ty>::~SingleList()
{	
	if(m_pHead->pNext != NULL)
	{
		deleteall();	// 释放所有空间
	}
	free(m_pHead);
}

// 在链表尾部插入元素
template
bool SingleList<_Ty>::append(_Ty elem)
{
	tagNode* pNewNode = (tagNode *)malloc(sizeof(tagNode));
	if(pNewNode == NULL)
	{
		return false;	// 内存空间分配失败
	}
	pNewNode->_elem = elem;
	pNewNode->pNext = NULL;
	m_pTitle->pNext = pNewNode;
	m_pTitle = pNewNode;
	++m_size;
	return true;
}

// 在链表任意位置插入元素
template
bool SingleList<_Ty>::insert(int pos,_Ty elem)	// pos指的是第几个元素的位置从1开始
{	
	int i = 0;
	// 不能破坏链表头
	tagNode* pCursor = m_pHead;	
	while(pCursor != NULL && i < pos - 1)	 // 偏移到插入元素位置
	{
		pCursor = pCursor->pNext;
		++i;
	}
	if(i > pos-1 || pCursor == NULL)
	{
		return append(elem);
	}
	tagNode* pNewNode = (tagNode *)malloc(sizeof(tagNode));
	if(pNewNode == NULL)
	{
		return false;	// 内存空间分配失败
	}
	pNewNode->_elem = elem;
	pNewNode->pNext = pCursor->pNext;
	pCursor->pNext = pNewNode;
	++m_size;
	return true;
}

// 删除链表所有节点
template
bool SingleList<_Ty>::deleteall()
{
	tagNode* pNode = m_pHead->pNext;
	tagNode* pTemp = NULL;
	while(pNode != NULL)
	{
		pTemp = pNode;
		pNode = pTemp->pNext;
		pTemp->_elem = 0;
		pTemp->pNext = NULL;
		free(pTemp);
		--m_size;
	}
	m_pHead->pNext = NULL;
	return true;
}

// 删除链表指定节点
template
bool SingleList<_Ty>::deletepos(int pos,_Ty& res)
{	
	if(pos > m_size || m_pHead->pNext == NULL) // 删除的元素不存在
	{
		return false;
	}
	tagNode* pNode = m_pHead;
	int i = 0;
	while(pNode != NULL && i < pos -1)	// 偏移到要删除元素位置
	{
		pNode = pNode->pNext;
		++i;
	}
	tagNode* pDelete = pNode->pNext;
	pNode->pNext = pDelete->pNext;
	pDelete->_elem = 0;
	pDelete->pNext = NULL;
	free(pDelete);
	--m_size;
	return true;
}

// 获取第一个元素
template
_Ty  SingleList<_Ty>::front()
{	
	return m_pHead->pNext->_elem;
}

// 获取最后一个一元素
template
_Ty SingleList<_Ty>::last()
{	
	return m_pTitle->_elem;
}

// 判断链表是否为空
template
bool SingleList<_Ty>::empty()
{
	if(m_pHead->pNext == NULL || m_size == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

// 遍历
template
void SingleList<_Ty>::traverse()
{
	tagNode* pTmp = m_pHead->pNext;
	if(pTmp == NULL || m_size == 0)
	{
		cout << "链表为空"<_elem << "\t";
		pTmp = pTmp->pNext;
	}
	return;
}

int main(int _args,char* _argc)
{	
	
	SingleList* pList = new SingleList;

	pList->append(1);
	pList->append(2);
	pList->append(3);
	pList->traverse();
	cout << endl;
	cout << pList->front()<