数据结构学习：单向链表的模板类实现

#pragma once
#ifndef NODE_H
#define NODE_H

#include <iostream>
using namespace std;

template<typename T>
class Node
{
public:
T data;//结点数据域
Node<T> *next;//结点指针域，指向下一个结点
void printNode();
};
#endif // !NODE_H

template<typename T>
void Node<T>::printNode()
{
cout << data << " ";
}

#pragma once
#ifndef LINKEDLIST_H
#define LINKEDLIST_H

#include "Node.h"
#include <iostream>
using namespace std;

template<typename T>
class LinkedList
{
private:
Node<T> *m_pList;//链表头指针
int m_iLength;//链表长度
public:
LinkedList();//创建链表
~LinkedList();//销毁链表
void clearList();//清空链表
bool ListEmpty();//判空
int ListLength();//链表中结点个数
bool getElem(int index, Node<T> *pNode);//根据索引获取链表中的结点
int locateElem(Node<T> *pNode);//返回结点出现的位置
bool priorElem(Node<T> *pCurrentNode, Node<T> *pPreNode);//获取前驱结点
bool nextElem(Node<T> *pCurrentNode, Node<T> *pNextNode);//获取后续结点
void ListTraverse();//遍历链表
bool ListInsert(int index, Node<T> *pNode);//在特定位置插入结点
bool ListDelete(int index, Node<T> *pNode);//删除特定位置的结点
bool ListInsertHead(Node<T> *pNode);//在链表头插入结点
bool ListInsertTail(Node<T> *pNode);//在链表尾插入结点
};
#endif // !LINKEDLIST_H

template<typename T>
LinkedList<T>::LinkedList()
{
m_pList = new Node<T>;
m_pList->data = 0;
m_pList->next = NULL;
m_iLength = 0;
}

template<typename T>
LinkedList<T>::~LinkedList()
{
clearList();
delete m_pList;
m_pList = NULL;
}

template<typename T>
void LinkedList<T>::clearList()
{
Node<T> *currentNode = m_pList->next;
while (currentNode != NULL)
{
Node<T> *temp = currentNode->next;
delete currentNode;
currentNode = temp;
}
m_pList->next = NULL;
}

template<typename T>
bool LinkedList<T>::ListEmpty()
{
if (m_iLength == 0)
return true;
else
return false;
}

template<typename T>
int LinkedList<T>::ListLength()
{
return m_iLength;
}

template<typename T>
bool LinkedList<T>::ListInsertHead(Node<T> *pNode)
{
Node<T> *temp = m_pList->next;
Node<T> *newNode = new Node<T>;
if (newNode == NULL)
{
return false;
}
newNode->data = pNode->data;
m_pList->next = newNode;
newNode->next = temp;
m_iLength++;
return true;
}

template<typename T>
bool LinkedList<T>::ListInsertTail(Node<T> *pNode)
{
Node<T> *currentNode = m_pList;
while (currentNode->next != NULL)
{
currentNode = currentNode->next;
}
Node<T> *newNode = new Node<T>;
if (newNode == NULL)
{
return false;
}
newNode->data = pNode->data;
newNode->next = NULL;
currentNode->next = newNode;
m_iLength++;
return true;
}

template<typename T>
bool LinkedList<T>::ListInsert(int index, Node<T> *pNode)
{
if (index<0 || index>m_iLength)
{
return false;
}
Node<T> *currentNode = m_pList;
for (int k = 0; k < index; k++)
{
currentNode = currentNode->next;
}
Node<T> *newNode = new Node<T>;
newNode->data = pNode->data;
newNode->next = currentNode->next;
currentNode->next = newNode;
m_iLength++;
return true;
}

template<typename T>
bool LinkedList<T>::ListDelete(int index, Node<T> *pNode)
{
if (index<0 || index>=m_iLength)
{
return false;
}
Node<T> *currentNode = m_pList;
Node<T> *currentNodeBefore = NULL;
for (int k = 0; k <= index; k++)
{
currentNodeBefore = currentNode;
currentNode = currentNode->next;
}
currentNodeBefore->next = currentNode->next;
pNode->data = currentNode->data;
delete currentNode;
currentNode = NULL;
m_iLength--;
return true;
}

template<typename T>
bool LinkedList<T>::getElem(int index, Node<T> *pNode)
{
if (index < 0 || index >= m_iLength)
{
return false;
}
Node<T> *currentNode = m_pList;
for (int k = 0; k <= index; k++)
{
currentNode = currentNode->next;
}
pNode->data = currentNode->data;
return true;
}

template<typename T>
int LinkedList<T>::locateElem(Node<T> *pNode)
{
Node<T> *currentNode = m_pList;
int count = 0;
while (currentNode->next != NULL)
{
currentNode = currentNode->next;
if (currentNode->data == pNode->data)
{
return count;
}
count++;
}
return -1;
}

template<typename T>
bool LinkedList<T>::priorElem(Node<T> *pCurrentNode, Node<T> *pPreNode)
{
Node<T> *currentNode = m_pList;
Node<T> *tempNode = NULL;
while (currentNode->next != NULL)
{
tempNode = currentNode;
currentNode = currentNode->next;
if (currentNode->data == pCurrentNode->data)
{
if (tempNode == m_pList)
{
return false;
}
pPreNode->data = tempNode->data;
return true;
}
}
return false;
}

template<typename T>
bool LinkedList<T>::nextElem(Node<T> *pCurrentNode, Node<T> *pNextNode)
{
Node<T> *currentNode = m_pList;
while (currentNode->next != NULL)
{
currentNode = currentNode->next;
if (currentNode->data = pCurrentNode->data)
{
if (currentNode->next == NULL)
{
return false;
}
pNextNode->data = currentNode->next->data;
return true;
}
}
return false;
}

template <typename T>
void LinkedList<T>::ListTraverse()
{
Node<T> *currentNode = m_pList;
while (currentNode->next != NULL)
{
currentNode = currentNode->next;
currentNode->printNode();
}
}