c++用户管理信息(双向链表)

ListStu双向链表–（把前面的单链表改一下，就直接可以用）

ListStu.h

#pragma once
#include "ClassStu.h"

class ListStu
{
public:
	struct StuNode
	{
		ClassStu m_cStu;//数据
		StuNode* m_pPro;//指向前一个节点
		StuNode* m_pNext;//指向下一个节点


		StuNode()
		{
			m_cStu = 0;
			m_pNext = nullptr;
			m_pPro = nullptr;
		}


		StuNode(ClassStu& Stu)
		{
			m_cStu = Stu;
			m_pNext = nullptr;
			m_pPro = nullptr;

		}
	};

	using pStuNode = StuNode*;
public:
     //迭代器类
	class Iterator
	{
	public:

		Iterator(pStuNode Current,pStuNode Head, pStuNode Vail)
		{
			m_Current = Current;
			m_Head = Head;
			m_Vail = Vail;
		}

		ClassStu& operator*()
		{
			return m_Current->m_cStu;
		}

		Iterator& operator++()
		{
			if (m_Current == nullptr)//不能是空
			{
				return *this;
			}
			if (m_Current == m_Vail)//不能是尾部节点
			{
				return *this;
			}
			m_Current = m_Current->m_pNext;
			return *this;
		}

		Iterator& operator--()
		{
			if (m_Current == nullptr)
			{
				return *this;
			}
			if (m_Current == m_Vail)
			{
				return *this;
			}
			m_Current = m_Current->m_pPro;
			return *this;
		}



		bool operator!=(Iterator Itr)
		{
			return m_Current != Itr.m_Vail;//不等于的时候返回真
		}

	private:
		friend class ListStu;
		pStuNode m_Current;//当前节点
		pStuNode m_Head;//头节点
		pStuNode m_Vail;//尾节点
	};


public:

	/*******************默认构造系列开始*************************/
/*
   * ListStu
   * 参数一 ： 无
   * 功能   ：默认构造，初始化类成员 --为空
   * 返回值 ：无
*/
	ListStu();


/*
	* ListStu
	* 参数一 ： int
	* 功能   ：默认构造，初始化nCount个成员链表
	* 返回值 ：无
*/
	ListStu(int nCount);
/*
	* ~ListStu
	* 参数一 ： 无
	* 功能   ：默认析构，释放资源
	* 返回值 ：无
*/
	~ListStu();

	/*******************默认构造系列结束*************************/

//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//

	/*******************增删改查系列开始*************************/
/*
	* HeadInsert
	* 参数一 ： ClassStu
	* 功能   ：从头部插入一个数据
	* 返回值 ：ListStu&
*/

	ListStu& HeadInsert(ClassStu& cStu);

/*
	* VailInsert
	* 参数一 ： ClassStu
	* 功能   ：从尾部插入一个数据
	* 返回值 ：ListStu&
*/

	ListStu& VailInsert(ClassStu& cStu);
/*
	* Insert
	* 参数一 ： pStuNode 需要插入节点的位置   插在这个节点的pStuNode后面
	* 参数二 ： ClassStu& 插入的数据
	* 功能   ： 指定位置插入一个数据
	* 返回值 ： ListStu&
*/

	ListStu& Insert(Iterator Itr,ClassStu& cStu);


/*
	* Detele
	* 参数一 ： pStuNode    删除的前一个节点
	* 功能   ： 从链表中删除一个节点
	* 返回值 ：ListStu&
*/
	ListStu& Delete(pStuNode PosNode);

/*
	* DeteleHead
	* 参数一 ： pStuNode   删除头部节点
	* 功能   ： 删除头部节点
	* 返回值 ： ListStu&
*/
	ListStu& DeleteHead();


/*
	* DeleteVail
	* 参数一 ： pStuNode   删除尾部节点
	* 功能   ： 删除尾部节点
	* 返回值 ： ListStu&
*/
	ListStu& DeleteVail();
/*
	* DeteleId
	* 参数一 ： 索引
	* 功能   ： 指定索引从链表中删除一个节点
	* 返回值 ： 无
*/
	ListStu& DeteleId(int nIndex);



/*
	* Find
	* 参数一 ： int --序号索引
	* 功能   ： 通过索引查找到数据
	* 返回值 ： 无
*/
	StuNode* Find(int nIndex);


/*
	* FindItr
	* 参数一 ： int --序号索引
	* 功能   ： 查找到数据
	* 返回值 ： Iterator   
*/
	Iterator FindItr(int nIndex);

/*
	* FindFOffset
	* 参数一 ： int --序号索引
	* 功能   ： 根据索引查找到文件偏移
	* 返回值 ： 无
*/
	int FindFOffset(int nIndex);

/*
	* FindId
	* 参数一 ：  int --序号索引
	* 功能   ： 根据索引查找到用户m_Id
	* 返回值 ： 无
*/
	int FindId(int nIndex);

/*
	* UserIdToIndex
	* 参数一 ：  int --用户的m_Id
	* 功能   ： 用户m_Id --查到链表用户的索引
	* 返回值 ： int  nIndex
*/
	int UserIdToIndex(int UserId);

/*
	* UpDate
	* 参数一 ： int --序号索引
	* 功能   ： 修改用户的数据
	* 返回值 ： 无
*/
	void UpDate(int nIndex,ClassStu& cStu);
	/*******************增删改查系列结束*************************/


	/*******************迭代器开始*************************/
/*
	* begin
	* 参数一 ： 无
	* 功能   ： 迭代器开始
	* 返回值 ： Iterator
*/

	Iterator begin()
	{
		return Iterator(m_HeaderStu->m_pNext, m_HeaderStu, m_VailStu);
	}
/*
	* end
	* 参数一 ： 无
	* 功能   ： 迭代器结束
	* 返回值 ： Iterator
*/
	Iterator end()
	{
		return Iterator(m_VailStu, m_HeaderStu, m_VailStu);
	}
	/*******************迭代器结束*************************/

	/*******************内部使用函数系列开始*************************/
/*
	* InitDate
	* 参数一 ： int --序号索引
	* 功能   ： 初始化类成员
	* 返回值 ： 无
*/
	void InitList();



/*
* GetMaxUserId
* 参数一 ： 无
* 功能   ： 查找用户最大的m_Id
* 返回值 ： int
*/
	int GetMaxUserId();


/*
	* size
	* 参数一 ： 无
	* 功能   ： 获取元素个数
	* 返回值 ： int
*/
	int Size();

/*
	* BubbleSort
	* 参数一 ： 无
	* 功能   ： 根据成员m_Id --冒泡排序
	* 返回值 ： 无
*/
	//void BubbleSort();

/*
	* insertionSort
	* 参数一 ： 无
	* 功能   ： 根据成员m_Id --插入排序法
	* 返回值 ： 无
*/
	//void insertionSort();
/*
	* Sort()
	* 参数一 ： 无
	* 功能   ： 根据成员m_Id --选择性排序法
	* 返回值 ： 无
*/
	void Sort();

	/*******************内部使用函数系列结束*************************/

private:
	pStuNode m_HeaderStu;//头节点
	pStuNode m_VailStu;//尾节点
	int m_nCount;//记录有多少个成员
};

ListStu.cpp

#include "ListStu.h"

ListStu::ListStu()
{
	InitList();
}

ListStu::ListStu(int nCount)
{
	InitList();
	for (int i = 0; i < nCount; i++)
	{
		ClassStu cStu;
		VailInsert(cStu);
	}
	
}

ListStu::~ListStu()
{
	//判断是否有成员
	if (m_nCount == 0)
	{
		return;
	}

	//释放资源
	//先赋值下一个，在删除当前，以此类推.
	pStuNode TmpbNode = m_HeaderStu->m_pNext;
	pStuNode TmpfNode = nullptr;
	for (int i = 0; i < m_nCount; i++)
	{
		TmpfNode = TmpbNode->m_pNext;
		delete TmpbNode;
		TmpbNode = TmpfNode;
	}
}

ListStu& ListStu::HeadInsert(ClassStu& cStu)
{
	return Insert(begin(), cStu);
}

ListStu& ListStu::VailInsert(ClassStu& cStu)
{
	return Insert(end(), cStu);
}

ListStu& ListStu::Insert(Iterator Itr, ClassStu& cStu)
{
	if (Itr.m_Current == nullptr)
	{
		return *this;
	}
	auto PosNode = Itr.m_Current;

	pStuNode ListNode = new StuNode(cStu);
	PosNode->m_pPro->m_pNext = ListNode;
	ListNode->m_pPro = PosNode->m_pPro;
	PosNode->m_pPro = ListNode;
	ListNode->m_pNext = PosNode;
	m_nCount++;
	return *this;
}

ListStu& ListStu::Delete(pStuNode PosNode)
{
	//判断传入的指针是否为空
	if (PosNode == nullptr)
	{
		return *this;
	}
	//断链  -- 画图
	PosNode->m_pPro->m_pNext = PosNode->m_pNext;
	PosNode->m_pNext->m_pPro = PosNode->m_pPro;
	//释放资源
	delete PosNode;
	//元素个数减减
	m_nCount--;
	return *this;
}

ListStu& ListStu::DeleteHead()
{

	return Delete(m_HeaderStu->m_pNext);
}

ListStu& ListStu::DeleteVail()
{
	if (m_VailStu->m_pPro == m_HeaderStu)
	{
		return *this;
	}
	return Delete(m_VailStu->m_pPro);
}

ListStu& ListStu::DeteleId(int nIndex)
{
	if (nIndex == 0)//索引为0 就是删除头部
	{
		return DeleteHead();
	}
	if (nIndex == (m_nCount-1))//索引等于元素个数就是删除尾部
	{
		return DeleteVail();
	}
	//查找需要删除的节点  
	pStuNode DeleteNode = Find(nIndex);
	//进行删除 并返回
	return Delete(DeleteNode);
}





ListStu::StuNode* ListStu::Find(int nIndex)
{

	//判断 成员个数不为0  nIndex是否有效的值
	if (m_nCount < 1 ||nIndex < 0 || nIndex > m_nCount)
	{
		return nullptr;
	}

	//遍历查找数据    
	pStuNode FindNode = m_HeaderStu->m_pNext;

	for (int i = 0; i < nIndex; i++)
	{
		FindNode = FindNode->m_pNext;

	}
	return FindNode;
}

ListStu::Iterator ListStu::FindItr(int nIndex)
{
	return Iterator(Find(nIndex),m_HeaderStu,m_VailStu);
}

int ListStu::FindFOffset(int nIndex)
{
	pStuNode pFindNode = Find(nIndex);
	if (pFindNode == nullptr)
	{
		return 0;
	}
	return pFindNode->m_cStu.m_FileOffset;
}

int ListStu::FindId(int nIndex)
{
	pStuNode pFindNode = Find(nIndex);
	if (pFindNode == nullptr)
	{
		return 0;
	}
	return pFindNode->m_cStu.m_Id;
}

int ListStu::UserIdToIndex(int UserId)
{
	int nIndex = 0;
	for (auto Val : *this)
	{
		if (UserId == Val.m_Id)
		{
			return nIndex;
		}
		nIndex++;
	}
	return -1;
}

void ListStu::UpDate(int nIndex, ClassStu& cStu)
{

	//先找到要修改的数据
	pStuNode pUpDate = Find(nIndex);
	//替换数据   -- cStu里面会自动释放资源
	pUpDate->m_cStu = cStu;
}

void ListStu::InitList()
{
	m_HeaderStu = new StuNode;
	m_VailStu = new StuNode;

	m_HeaderStu->m_pNext = m_VailStu;
	m_VailStu->m_pPro = m_HeaderStu;
	m_nCount = 0;
}

int ListStu::GetMaxUserId()  //已经排好序的，只要取尾节点的前一个节点的m_Id
{
	return m_VailStu->m_pPro->m_cStu.m_Id;
}

int ListStu::Size()
{
	return m_nCount;
}




	void ListStu::Sort()//适合用选择性排序法了
	{
		auto nTmp = m_HeaderStu->m_pNext;//第一个节点数据
		auto cTmp = nTmp->m_pNext;//第二个节点数据
		for (int i = 0; i < m_nCount - 1; i++)
		{
			for (int j = 0 + i; j < m_nCount - 1; j++)
			{

				if ((nTmp->m_cStu.m_Id) > (cTmp->m_cStu.m_Id))//不停的遍历cTmp下一个
				{
					//交换数据就好
					auto nNumber = nTmp->m_cStu;
					nTmp->m_cStu = cTmp->m_cStu;
					cTmp->m_cStu = nNumber;
				}
				cTmp = cTmp->m_pNext;

			}
			nTmp = nTmp->m_pNext;
			cTmp = nTmp->m_pNext;//重新赋值cTmp为nTmp的下一个节点
		}

	}