C++单链表指针实现 构造析构、相关操作及运算符重载

2个月没有发文章了，因为玩了两个月。。。开学后才又开始了学习。

先来看一下我们要实现的单链表相关操作有哪些，然后再一个个来给出代码。

目录

一、概述：

二、节点Node的定义：

三、构造函数、析构函数：

1.默认构造函数：

2.复制构造函数：

3.析构函数：

 四、相关操作：

1.链表长度length():

2.插入新节点insert():

3. 打印链表所有节点的值display()：

4.删除某个值erase()：

5.更改某个数据change()：

6.查找某个值的下标search()：

7.链表反转reverse()：

五、运算符重载：

1.=：

2.<<:

3. >> :

---

一、概述：

#include<iostream>
using namespace std;
typedef int ElementType;

class LinkList
{
	//运算符<<和>>的重载
	friend ostream & operator<<(ostream & cout, LinkList & L);
	friend istream & operator>>(istream & cin, LinkList & L);
private:
	//节点Node
	class Node
	{
	public:
		ElementType value;
		Node * next;
		Node() :value(0), next(NULL) {};
		Node(ElementType input_value) :value(input_value), next(NULL) {};
	};
	int nodenumber;//节点个数nodenumber
	Node * first;//头first
public:
	LinkList();//默认构造函数
	LinkList(const LinkList & List2);//复制构造函数
	~LinkList();//析构函数

	int length();//链表长度
	bool insert(ElementType data, int index);//在某个位置插入新节点
	void display();//打印链表的每个节点值
	bool erase(ElementType data);//删除某个数据
	bool change(ElementType data, int index);//更改某个数据

	int search(ElementType data);//查找某个数据的下标
	LinkList& reverse();//链表反转

	LinkList & operator=(LinkList L2);//=重载
};

我们要实现的功能已经在以上代码 类LinkList 中注释说明了。

二、节点Node的定义：

class Node
	{
	public:
		ElementType value;
		Node * next;
		Node() :value(0), next(NULL) {};
		Node(ElementType input_value) :value(input_value), next(NULL) {};
	};

在Node中定义了节点值value、指向下一个Node的指针next以及两个构造函数（在创建Node时可以选择默认构造：value为0，next指向NULL，或者选择有参构造：为Node选择合适的value值）。

三、构造函数、析构函数：

1.默认构造函数：

LinkList::LinkList() :nodenumber(0), first(NULL) {};

默认构造函数中我们用初始化列表将节点数量设为0、头指针设为NULL。

2.复制构造函数：

这位重量级的来了！

为什么要自己写复制构造函数呢？因为C++提供的复制构造函数只是将一个类中的成员的值复制给令一个类，这导致了两个链表的first值是相同的，即两个链表的first指向了同一块内存空间，而当我们最后对这两个类使用析构函数释放first指向的那个空间时那个空间会被释放两次，第一次是正常的释放，但是第二次释放时会发现first指向的空间不存在（第一次时已经释放）。

所以复制时我们要为新链表开辟新的内存空间，让它指向新空间，而新空间中的值与旧链表一样。

LinkList::LinkList(const LinkList & List2)
{
	nodenumber = List2.nodenumber;
	if (List2.first == NULL) return;
	else
	{
		first = new Node(List2.first->value);
		Node * ptr = first;
		Node * temp = List2.first->next;
		while(temp != NULL)
		{
			ptr->next = new Node(temp->value);
			temp = temp->next;
			ptr = ptr->next;
		}
	}
}

3.析构函数：

我们要把链表中的每一个节点都删除，而不是只删除first指向的空间。

最后将节点数归0。

LinkList::~LinkList()
{
	Node * ptr = first;
	Node* next = NULL;
	while (ptr != NULL)
	{
		next = ptr->next;
		delete ptr; 
		ptr = next;
	}
	nodenumber = 0;
}

 四、相关操作：

1.链表长度length():

int LinkList::length()
{
	return nodenumber;
}

2.插入新节点insert():

bool LinkList::insert(ElementType data, int index)
{
	if (index < 0 || index > nodenumber) return false;

	Node * newnode = new Node(data);
	if (index == 0)
	{
		newnode->next = first;
		first = newnode;
	}
	else
	{
		Node * ptr = first;
		Node * ptr2 = NULL;
		for (int i = 0; i < index - 1; i++)
			ptr = ptr->next;
		ptr2 = ptr->next;
		ptr->next = newnode;
		newnode->next = ptr2;
	}
	nodenumber++;
	return true;
}

3. 打印链表所有节点的值display()：

void LinkList::display()
{
	Node * ptr = first;
	while (ptr != NULL)
	{
		cout << ptr->value << " ";
		ptr = ptr->next;
	}
}

4.删除某个值erase()：

bool LinkList::erase(ElementType data)
{
	if (first == NULL) return false;
	Node * temp = NULL;
	int flag = 0;
	if (first->value == data)
	{
		temp = first->next;
		delete first;
		first = temp;
		nodenumber--;
		flag = 1;
	}
	else
	{
		temp = first;
		while (temp->next != NULL)
		{
			if (temp->next->value == data)
			{
				Node * ptr = temp->next->next;
				delete temp->next;
				temp->next = ptr;
				nodenumber--;
				flag = 1;
				break;
			}
			else temp = temp->next;
		}
	}
	return flag;
}

5.更改某个数据change()：

bool LinkList::change(ElementType data, int index)
{
	int flag = 1;
	if (index < 0 || index > nodenumber) flag = 0;
	Node * ptr = first;
	for (int i = 0; i < index; i++)
		ptr = ptr->next;
	ptr->value = data;

	return flag;
}

6.查找某个值的下标search()：

int LinkList::search(ElementType data)
{
	int flag = -1;
	Node * ptr = first;
	int i;
	for (i = 0; i < nodenumber; i++)
	{
		if (ptr->value == data)
		{
			flag = i;
			break;
		}
		ptr = ptr->next;
	}
	return flag;
}

7.链表反转reverse()：

LinkList & LinkList::reverse()
{
	Node * before = NULL; //Node * before, behind是错误的,behind 被认为是Node;
	Node * behind = NULL;
	Node * ptr = first;
	while (ptr != NULL)
	{
		behind = ptr->next;
		ptr->next = before;
		before = ptr;
		ptr = behind;
	}
	first = before;
	return *this;
}

五、运算符重载：

1.=：

LinkList & LinkList::operator=(LinkList L2)
{
	if (first == NULL);
	else
	{
		Node * ptr = first->next;
		delete first;
		Node * next = NULL;
		while (ptr != NULL)
		{
			next = ptr->next;
			delete ptr;
			ptr = next;
		}
	}
	nodenumber = L2.nodenumber;
	if (L2.first == NULL) first = NULL;
	else
	{
		first = new Node(L2.first->value);
		Node * ptr1 = first;
		Node * ptr2 = L2.first->next;
		for (int i = 0; i < nodenumber - 1; i++)
		{
			Node * temp = new Node(ptr2->value);
			ptr1->next = temp;
			ptr1 = ptr1->next;
			ptr2 = ptr2->next;
		}
	}
	return *this;
}

2.<<:

ostream & operator<<(ostream & cout, LinkList & L)
{
	LinkList::Node * ptr = L.first;
	while (ptr != NULL)
	{
		cout << ptr->value << " ";
		ptr = ptr->next;
	}
	cout << endl;
	return cout;
}

3. >> :

istream & operator>>(istream & cin, LinkList & L)
{
	ElementType inputvalue;
	LinkList::Node * ptr = NULL;
	int flag = 1;
	while (cin >> inputvalue)
	{
		L.nodenumber++;
		LinkList::Node * newnode = new LinkList::Node(inputvalue);
		if (flag == 1)
		{
			L.first = newnode;
			ptr = L.first;
			flag = 0;
		}
		else {
			ptr->next = newnode;
			ptr = ptr->next;
		}
	}
	return cin;
}