面向对象程序设计|链表

题目一：单链表

题目描述：

单链表节点的存储结构为:

struct SNode

{

int data;

SNode *next;

};

定义单链表类CList，数据成员有表头指针(SNode *head)，成员函数有：

1. 构造函数：初始化head.

2. createList(int *value, int n): 用value中的n个数据创建单链表.

3. printList(): 以head为表头依次输出每个节点的数据值。

4. insertNode(int pos, int value): 在单链表第pos个节点位置后插入新节点，数据为value。如插入不成功输出error。

5. removeNode(int pos): 删除第pos个节点，若删除不成功输出error。

6. 析构函数：释放链表每个节点的堆内存。

输入要求：

第一行：测试次数

每次测试格式为：

数据个数n 数据1 数据2 ... 数据n

插入次数m

插入位置1 数据1

...

插入位置m 数据m

删除次数k

删除位置1

...

删除位置k

输出要求：

每次测试产生的输出格式为：

输出创建链表后全部节点的数据

对每组插入测试数据：

输出插入操作后链表全部节点的数据

对每组删除测试数据：

输出删除操作后链表全部节点的数据

输入样例：

2
5 2 3 5 7 3
2
1 40
7 60
2
7
3
6 1 2 10 0 1 5
2
1 40
7 60
2
1
3

输出样例：

2 3 5 7 3
2 40 3 5 7 3
error
error
2 40 5 7 3
1 2 10 0 1 5
1 40 2 10 0 1 5
1 40 2 10 0 1 5 60
40 2 10 0 1 5 60
40 2 0 1 5 60

#include
#include
#include
#include 
#include
#include
using namespace std;

class CNode//节点类
{
public:
	CNode(int e = 0, CNode* nextval = nullptr);
	void setData(int e);
	void setNext(CNode* nextval);
	int getData();
	CNode* getNext();
private:
	int data;
	CNode* next;
};

class CList//链表类
{
public:
	CList();
	void createList(int num[], int n);//创建链表
	void printList();//打印链表
	int insertNode(int i, int e);//插入数据
	int removeNode(int i, int& e);//删除数据
	CNode* find(int i);
	~CList();
private:
	CNode* head;
};

CList::CList()//无参构造
{
	head = new CNode;
}

void CList::createList(int num[], int n)
{
	CNode* tail = head;//节点类型的tail指针指向表头
	for (int i = 0; i < n; i++)
	{
		CNode* s = new CNode(num[i], nullptr);//建立新的节点，总共n个，先传入数据后传入指针
		tail->setNext(s);//最总的链表存放在tail中，s只作为一个具有寄存器作用的变量，用于把链表每个位置的数据存到tail中
		tail = s;
	}
}

int CList::insertNode(int i, int e)
{
	CNode* p = find(i);//查找链表位置是否存在
	if (!p)
	{
		return 0;
	}
	else
	{
		CNode* s = new CNode(e, p->getNext());//如果存在插入到链表中，用动态内存分配理解
		p->setNext(s);//新建的节点数据是自身的，而节点指针则是找到的节点位置的指针，很自然的把自己与后面的数据关联起来
		return 1;
	}
}

int CList::removeNode(int i, int& e)//删除节点
{
	CNode* p = find(i - 1);
	if (!p)
	{
		return 0;
	}
	CNode* q = p->getNext();
	if (!q)
	{
		return 0;
	}
	p->setNext(q->getNext());
	e = p->getData();
	delete q;
	return 1;
}

void CList::printList()//打印链表
{
	CNode* p = head->getNext();//从表头的下一个开始
	while (p->getNext())//非空即有下一个，打印
	{
		cout << p->getData() << " ";
		p = p->getNext();
	}
	cout << p->getData() << endl;
}
CList::~CList()//析构函数
{
	CNode* p = head;
	//cout << p << endl;
	while (p)
	{
		CNode* q = p;
		p = p->getNext();
		delete q;
	}
}

CNode* CList::find(int i)//查找函数
{
	int count = 0;
	CNode* cur = head;
	if (i < 0)//位置要大于0
	{
		return nullptr;
	}
	while (cur  && count < i )//cur为空指针则结束循环，你找到i，就找到它前一个位置的next指针，要用count来限制位置条件
	{
		cur = cur->getNext();
		count++;
	}
	return cur;
}

CNode::CNode(int e, CNode* nextval)//节点带参构造
{
	data = e;
	next = nextval;
}

void CNode::setData(int e)//设置数据值
{
	data = e;
}

void CNode::setNext(CNode* nextval)//next等于下一个指针
{
	next = nextval;
}

int CNode::getData()//得到数据值
{
	return data;
}

CNode* CNode::getNext()//得到next指针
{
	return next;
}

int main()
{
	int t;
	cin >> t;
	while (t--)//测试次数
	{
		CList l;//定义链表l
		int n;
		cin >> n;
		int* arr = new int[n];//建立动态内存数组
		for (int i = 0; i < n; i++)
		{
			cin >> arr[i];
		}
		l.createList(arr, n);//创建列表
		l.printList();
		int ninsert;
		cin >> ninsert;
		for (int i = 0; i < ninsert; i++)
		{
			int index, datai;
			cin >> index >> datai;
			if (l.insertNode(index, datai))//如果能插入成功，则执行插入操作并返回1，进而进行打印
			{
				l.printList();
			}
			else
			{
				cout << "error" << endl;//不能则返回0，输出error
			}
		}
		int nremove;
		cin >> nremove;
		for (int i = 0; i < nremove; i++)//与插入操作同理
		{
			int digit, e;
			cin >> digit;
			if (l.removeNode(digit, e))
			{
				l.printList();
			}
			else
			{
				cout << "error" << endl;
			}
		}
	}
	return 0;
}