链表学习笔记

最新推荐文章于 2024-06-29 01:00:10 发布

zfdyq0

最新推荐文章于 2024-06-29 01:00:10 发布

阅读量712

点赞数

文章标签：链表单链表遍历双链表

本文链接：https://blog.csdn.net/zfdyq0/article/details/39234733

版权

自己整理的链表简单操作，修改成了模板，记录一下，方便复习

单链表：

#pragma once
#include <string.h>


template <class TYPE>
class CMyList
{
public:

	typedef struct _NODE
	{
		TYPE nData;
		_NODE* pNext;

	}NODE, *PNODE;

	CMyList()
	{
		memset(&m_stcHead, 0, sizeof(NODE));
		m_nCount = 0;
	}
	~CMyList(){ Clear(); };
public:

	// 向尾部添加一个元素
	void push_back(TYPE nData)
	{
		// 1.获取头结点地址
		NODE* pNew = &m_stcHead;
		// 2.从头结点开始遍历每个节点找到为空的pNext
		while (pNew->pNext)
		{
			pNew = pNew->pNext;
		}
		// 3.创建一个新结点
		pNew->pNext = new NODE;
		memset(pNew->pNext, 0, sizeof(NODE));
		pNew->pNext->nData = nData;
		// 将新结点的pNext指向空
		pNew->pNext->pNext = nullptr;
		// 4.结点数量加1；
		m_nCount++;
	}

	// 向nIndex插入一个元素
	void Insert(int nIndex, TYPE nData)
	{
		// 1.先获取头结点的地址
		NODE* pNew = &m_stcHead;
		// 2.从头结点开始遍历找到nIndex，记录pNew结点
		int nCurrentPos = 0;
		while (pNew->pNext)
		{
			if (nCurrentPos == nIndex)
				break;
			pNew = pNew->pNext;
			nCurrentPos++;
		}
		// 3.保存当前结点的下一个结点的地址
		NODE* pOld = pNew->pNext;
		// 4.插入新的结点
		pNew->pNext = new NODE;
		memset(pNew->pNext, 0, sizeof(NODE));
		pNew->pNext->nData = nData;
		// 5.插入结点的pNext指向刚刚保存的节点的地址
		pNew->pNext->pNext = pOld;

		m_nCount++;	//增加元素
	}

	// 删除nIndex结点
	void Delete(int nIndex)
	{
		// 1.先获取头结点的地址
		NODE* pNew = &m_stcHead;
		// 2.从头结点开始遍历找到nIndex，记录pNew结点
		int nCurrentPos = 0;
		while (pNew->pNext)
		{
			if (nCurrentPos == nIndex)
				break;
			pNew = pNew->pNext;
			nCurrentPos++;
		}
		NODE* pDel = pNew->pNext;
		pNew->pNext = pDel->pNext;
		delete pDel;
		pDel = nullptr;
		m_nCount--;
	}

	// 清空链表
	void Clear()
	{
		if (m_nCount > 0)	//判断是否有结点
		{
			// 1.先获取头结点的地址
			NODE* pDel = &m_stcHead;
			NODE* pDelNext = pDel->pNext;
			while (pDelNext)
			{
				pDel = pDelNext;
				pDelNext = pDel->pNext;
				delete pDel;
				pDel = nullptr;
			}
			m_nCount = 0;
		}
	}


private:
	NODE m_stcHead;
	int  m_nCount;
};

循环单链表：

#pragma once
#include <string.h>


template <class TYPE>
class CMyLoopList
{
public:

	typedef struct _NODE
	{
		TYPE nData;
		_NODE* pNext;

	}NODE, *PNODE;

	CMyLoopList()
	{
		memset(&m_stcHead, 0, sizeof(NODE));
		m_stcHead.pNext = &m_stcHead;
		m_nCount = 0;
	}
	~CMyLoopList(){ Clear(); };
public:

	// 向尾部添加一个元素
	void push_back(TYPE nData)
	{
		// 1.获取头结点地址
		NODE* pNew = &m_stcHead;
		// 2.从头结点开始遍历每个节点找到为空的pNext
		while (pNew->pNext != &m_stcHead)
		{
			pNew = pNew->pNext;
		}
		// 3.创建一个新结点
		pNew->pNext = new NODE;
		memset(pNew->pNext, 0, sizeof(NODE));
		pNew->pNext->nData = nData;
		// 将新结点的pNext指向头结点
		pNew->pNext->pNext = &m_stcHead;

		// 4.结点数量加1；
		m_nCount++;
	}

	// 向nIndex插入一个元素
	void Insert(int nIndex, TYPE nData)
	{
		// 1.先获取头结点的地址
		NODE* pNew = &m_stcHead;
		// 2.从头结点开始遍历找到nIndex，记录pNew结点
		int nCurrentPos = 0;
		while (pNew->pNext != &m_stcHead)
		{
			if (nCurrentPos == nIndex)
				break;
			pNew = pNew->pNext;
			nCurrentPos++;
		}
		// 3.保存当前结点的下一个结点的地址
		NODE* pOld = pNew->pNext;
		// 4.插入新的结点
		pNew->pNext = new NODE;
		memset(pNew->pNext, 0, sizeof(NODE));
		pNew->pNext->nData = nData;
		// 5.插入结点的pNext指向刚刚保存的节点的地址
		pNew->pNext->pNext = pOld;

		m_nCount++;	//增加元素
	}

	// 删除nIndex结点
	void Delete(int nIndex)
	{
		// 1.先获取头结点的地址
		NODE* pNew = &m_stcHead;
		// 2.从头结点开始遍历找到nIndex，记录pNew结点
		int nCurrentPos = 0;
		while (pNew->pNext != &m_stcHead)
		{
			if (nCurrentPos == nIndex)
				break;
			pNew = pNew->pNext;
			nCurrentPos++;
		}
		NODE* pDel = pNew->pNext;
		pNew->pNext = pDel->pNext;
		delete pDel;
		pDel = nullptr;
		m_nCount--;
	}

	// 清空链表
	void Clear()
	{
		if (m_nCount > 0)	//判断是否有结点
		{
			// 1.先获取头结点的地址
			NODE* pDel = &m_stcHead;
			NODE* pDelNext = pDel->pNext;
			while (pDelNext && pDelNext != &m_stcHead)
			{
				pDel = pDelNext;
				pDelNext = pDel->pNext;
				delete pDel;
				pDel = nullptr;
			}
			m_nCount = 0;
		}
	}

private:
	NODE m_stcHead;
	int  m_nCount;
};

循环双链表：

#pragma once
#include <string.h>


template <class TYPE>
class CMyDoubleList
{
public:

	typedef struct _NODE
	{
		TYPE nData;
		_NODE* pPrev;
		_NODE* pNext;

	}NODE, *PNODE;


	CMyDoubleList()
	{
		//初始化
		memset(&m_stcHead, 0, sizeof(NODE));
		m_stcHead.pNext = &m_stcHead;
		m_nCount = 0;
	}
	~CMyDoubleList(){};

public:
	// 向尾部添加一个元素
	void push_back(TYPE nData)
	{
		// 1.获取头结点地址
		NODE* pNew = &m_stcHead;
		NODE* pPrev = pNew;
		// 2.从头结点开始遍历每个节点找到为空的pNext
		while (pNew->pNext != &m_stcHead)
		{
			pNew = pNew->pNext;
			pPrev = pNew;
		}
		// 3.创建一个新结点
		pNew->pNext = new NODE;
		memset(pNew->pNext, 0, sizeof(NODE));
		pNew->pNext->nData = nData;
		pNew->pNext->pPrev = pPrev;
		// 将新结点的pNext指向头结点
		pNew->pNext->pNext = &m_stcHead;

		// 4.结点数量加1；
		m_nCount++;
	}

	// 向nIndex插入一个元素
	void Insert(int nIndex, TYPE nData)
	{
		// 1.先获取头结点的地址
		NODE* pNew = &m_stcHead;
		NODE* pPrev = pNew;
		// 2.从头结点开始遍历找到nIndex，记录pNew结点
		int nCurrentPos = 0;
		while (pNew->pNext != &m_stcHead)
		{
			if (nCurrentPos == nIndex)
				break;
			pNew = pNew->pNext;
			pPrev = pNew;
			nCurrentPos++;
		}
		// 3.保存当前结点的下一个结点的地址
		NODE* pOld = pNew->pNext;
		// 4.插入新的结点
		pNew->pNext = new NODE;
		memset(pNew->pNext, 0, sizeof(NODE));
		pNew->pNext->nData = nData;
		pNew->pNext->pPrev = pPrev;
		// 5.插入结点的pNext指向刚刚保存的节点的地址
		pNew->pNext->pNext = pOld;

		m_nCount++;	//增加元素
	}

	// 删除nIndex结点
	void Delete(int nIndex)
	{
		// 1.先获取头结点的地址
		NODE* pNew = &m_stcHead;
		// 2.从头结点开始遍历找到nIndex，记录pNew结点
		int nCurrentPos = 0;
		while (pNew->pNext != &m_stcHead)
		{
			if (nCurrentPos == nIndex)
				break;
			pNew = pNew->pNext;
			nCurrentPos++;
		}
		NODE* pDel = pNew->pNext;
		pNew->pNext = pDel->pNext;
		pNew->pNext->pPrev = pNew;
		delete pDel;
		pDel = nullptr;
		m_nCount--;
	}

	// 清空链表
	void Clear()
	{
		if (m_nCount > 0)	//判断是否有结点
		{
			// 1.先获取头结点的地址
			NODE* pDel = &m_stcHead;
			NODE* pDelNext = pDel->pNext;
			while (pDelNext && pDelNext != &m_stcHead)
			{
				pDel = pDelNext;
				pDelNext = pDel->pNext;
				delete pDel;
				pDel = nullptr;
			}
			m_nCount = 0;
		}
	}


private:
	NODE m_stcHead;
	int  m_nCount;

};