数据结构和算法--单链表（C++实现）

#include <iostream>

template<typename T>
struct list_node
{
	list_node() : next(nullptr) {}
	list_node(const T& d) : next(nullptr), data(d) {}
	list_node* next;
	T data;
};

template<typename T>
class SingleLinkList
{
public:
	SingleLinkList();
	~SingleLinkList();

	void mvPushBack(const T& d);               // 尾部插入节点
	void mvPushFront(const T& d);              // 头部插入节点
	void mvInsert(int i, const T& d);          // 下标为i后面插入节点
	void mvDeleteNode(int i);                  // 删除索引为i的结点
	bool mbGetNodeData(int i, T& data);        // 获取索引为i的节点值
	int miGetCount() { return miCount;  }

private:
	typedef list_node<T>* link_type;

private:
	bool mbCheckIndex(int i);           // 检查下标是否有效
	link_type mopNewNode(const T& d);   // 创造新节点
	link_type mopFind(int i);           // 查找下标为i的节点

	link_type mopHead; // 头结点
	int miCount;       // 节点数
};

template<typename T>
SingleLinkList<T>::SingleLinkList() : mopHead(nullptr), miCount(0)
{
	mopHead = new list_node<T>();
}

template<typename T>
SingleLinkList<T>::~SingleLinkList()
{
	if (mopHead != nullptr) {
		link_type pDelNode = mopHead->next;
		while (pDelNode != nullptr) {
			mopHead->next = pDelNode->next;
			delete pDelNode;
			pDelNode = mopHead->next;
		}
	}

	if (mopHead != nullptr) {
		delete mopHead;
		mopHead = nullptr;
	}
}

template<typename T>
void SingleLinkList<T>::mvPushBack(const T& d)
{
	// 创建新节点
	link_type opNewNode = mopNewNode(d);

	// 找到尾节点
	link_type opTailNode = mopHead;
	if (miCount > 0) {
		opTailNode = mopFind(miCount - 1);
	}

	// 尾插入新节点
	opTailNode->next = opNewNode;

	// 结点总数加1
	++miCount;
}

template<typename T>
void SingleLinkList<T>::mvPushFront(const T& d)
{
	// 创建新节点
	link_type opNewNode = mopNewNode(d);

	// 头插入新节点
	opNewNode->next = mopHead->next;
	mopHead->next = opNewNode;

	// 更新结点总数
	++miCount;
}

template<typename T>
void SingleLinkList<T>::mvInsert(int i, const T& d)
{
	// 检查插入的下标是否有效
	if (!mbCheckIndex(i)) {
		return;
	}

	// 创建新节点
	link_type opNewNode = mopNewNode(d);

	// 获取下标对应的节点
	link_type opFindNode = mopFind(i);

	// 插入节点
	opNewNode->next = opFindNode->next;
	opFindNode->next = opNewNode;

	// 更新结点总数
	++miCount;
}

template<typename T>
void SingleLinkList<T>::mvDeleteNode(int i)
{
	// 检查插入的下标是否有效
	if (!mbCheckIndex(i)) {
		return;
	}

	// 获取删除结点的前一个节点
	link_type opPreNode = mopHead;
	if ((i - 1) > 0) {
		opPreNode = mopFind(i - 1);
	}
	// 获取需要删除的节点
	link_type opDelNode = mopFind(i);

	// 将前一个节点的next指针值向下一个节点
	opPreNode->next = opDelNode->next;

	// 删除结点
	delete opDelNode;
	opDelNode = nullptr;

	// 更新结点总数
	--miCount;
}

template<typename T>
bool SingleLinkList<T>::mbGetNodeData(int i, T& data)
{
	// 检查插入的下标是否有效
	if (!mbCheckIndex(i)) {
		return false;
	}

	// 获取下标对应的节点
	link_type opFindNode = mopFind(i);

	// 赋值
	data = opFindNode->data;

	return true;
}

template<typename T>
list_node<T>* SingleLinkList<T>::mopNewNode(const T& d)
{
	link_type opNewNode = new list_node<T>(d);
	return opNewNode;
}

template<typename T>
bool SingleLinkList<T>::mbCheckIndex(int i)
{
	bool ret = true;
	if ((i < 0) || (i > (miCount - 1))) {
		std::cout << "The entered index " << i << " is invalid." << std::endl;
		ret = false;
	}
	return ret;
}

template<typename T>
list_node<T>* SingleLinkList<T>::mopFind(int i)
{
	link_type retNode = mopHead->next;
	while (i--) {
		retNode = retNode->next;
	}
	
	return retNode;
}

int main()
{
	SingleLinkList<int> sll;
	sll.mvPushBack(10);
	sll.mvPushFront(5);
	sll.mvInsert(0, 6);
	sll.mvDeleteNode(0);

	return 0;
}