devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++通过类实现单链表（保姆级教程，附源码，可实现多种操作）_while(head->next!=null)

作者：小丑西瓜9 | 2024-06-11 13:48:00

赞

踩

while(head->next!=null)

源码提取链接：百度网盘 请输入提取码百度网盘为您提供文件的网络备份、同步和分享服务。空间大、速度快、安全稳固，支持教育网加速，支持手机端。注册使用百度网盘即可享受免费存储空间https://pan.baidu.com/s/1_Yl1tg7TXJERmk7qaOc29g
提取码：s7h1

目录

0.需要引入的库函数

1.认识和构造链表

1.1什么是链表

1.1.1节点

1.1.2链表的连接方式

1.1.3链表的灵魂——head指针

1.1.4链表的构造——带头结点&不带头结点

1.1.5编写析构函数（必写）

1.2空链表及链表的判空条件

2.基础功能实现

2.1返回头指针

2.2返回with_head值（用以外部判断带不带头结点）

2.3返回尾指针

2.4清空链表

2.5链表的长度获取

2.6输入数据构造链表

2.7输出链表

3.更多有意思的方法实现

3.1按位查找结点（返回第i个结点的结点指针）

3.2按值查找（返回其所在结点是第几个）

3.3保存第k个结点的信息（需要提供一个datas结构体来存储）

3.4按位删除结点

3.5按值删除

3.6翻转链表

4.插值

4.1按位插入

4.2单调性判别

4.3按值插入

4.4改进按位插入

5.一些测试函数（自己调试的时候写的）

5.1方法函数测试

5.2带头结点链表测试

5.3不带头结点链表测试

6.LinkList类整合

0.需要引入的库函数

  1. #include <iostream>
  2. #include <string>

1.认识和构造链表

1.1什么是链表

老规矩，先康康百度百科对它的定义

1.1.1节点

 可见链表的最小组成单元便是节点，如下图所示，节点则一般由两部分构成——1.数据2.next指针（用于指向下一节点）。

那便先定义一个最小组成单元节点吧！因为囊括了两个部分，所以我们采用结构体来储存这俩数据。那么问题来了，数据data是什么数据类型，指针类型又是什么呢？

data的类型好办，想存一个整形那就来个int data;想存个字符那就char data;但是如果我比较贪，我既想保存一个数字又想保存一串字符呢？那就采用一个结构体来保存数据吧！该部分代码如下：

  1. typedef struct datas
  2. {
  3. 	int num;
  4. 	string intro;
  5. 	datas()
  6. 	{
  7. 		num = 0;
  8. 		intro = "无";
  9. 	};
  10. 	datas(int n, string s)
  11. 	{
  12. 		num = n;
  13. 		intro = s;
  14. 	};
  15. }datas;

这样我们就定义好了一个结构体datas，它囊括两个信息——1.一个整型数据num2.一个字符串intro

并且定义了两种构造方式——无参构造时让数字为0信息为“无”，有参构造时第一个参数传给整形数据，第二个传给字符串数据。

接下来想一想next指针的类型应该是啥，前面说了next指针是用来指向下一节点的地址的，那么假设节点的类型是NodeType，那么next的类型即为NodeType*。而前面又说了节点我们应该构造成一个结构体，欸嘿这一来就成了。

我们得到了节点结构体node。 

  1. typedef struct node
  2. {
  3. 	datas* information;
  4. 	node* next;
  5. }node;

 （其中information是指向datas结构体的一个指针。）

再来完善一手这个结构体，既然定义了一个结构体那我们不妨给它也写上构造函数好了。先考虑一下无参构造，无参构造时只需要构造一个能放入数据的孤立节点就好。

什么是孤立节点呢？这是我随口胡诌的词哈哈哈，就是说这一个节点的data部分是可以存入数据滴，但是它的next指针指向NULL，意思就是它和其他任何节点没有关联，就像一个孤儿，所以我叫它孤儿孤立节点。

这么一来无参构造的方式就很明确了，给information分配一个内存以确保可以存入数据，再将next指向NULL，如此一来便大功告成!

  1. node() //无参构造结点
  2. {
  3. 	information = new datas;
  4. 	next = NULL;
  5. };

再来带参构造一个节点，我们关心的只有俩参数，一个是数据指针information（代表这个节点包含何种信息），一个是next指针（指明这个节点将要带领我们去向何方），但往往我们带参只是想建立一个有初始数据的孤立节点，比如下面要说的无头节点链表中的构造方式。 

总的来说带参构造节点时information取何值必须与用户交互，而next可以给以默认值 NULL来构造成带值的孤立节点。于是我们得到了如下的带参构造函数：

  1. node(datas& item, node* ptr = NULL) //带参构造结点（无头结点）
  2. {
  3. 	information = &item;
  4. 	next = ptr;
  5. };

这时候发挥一下裁缝天赋，将上面的node结构体和两种构造方式一缝合，欸嘿，就得到了完整的节点结构体：

  1. //节点类结构体
  2. typedef struct node
  3. {
  4.  
  5. 	datas* information;
  6. 	node* next;
  7. 	node() //无参构造节点
  8. 	{
  9. 		information = new datas;
  10. 		next = NULL;
  11. 	};
  12. 	node(datas& item, node* ptr = NULL) //带参构造节点（无头节点）
  13. 	{
  14. 		information = &item;
  15. 		next = ptr;
  16. 	};
  17.  
  18. }node;

1.1.2链表的连接方式

知道和构造好了最小组成单元之后再需要figure out的就是组成方式，即链表是通过怎样的方式将一个个最小组成单元——节点连接在一起的。（突然放洋屁哈哈哈）

链表的连接方式很简单，即将每一个节点的next指针指向下一个节点的地址。假设我们有两个孤立节点指针node1, node2（注意这里node1,node2都是节点指针node*，指向两个孤立节点），这时我们将他们连接起来：node1->next = node2;这样就得到了一个长度为2的链表，好耶！

那这时候我们就可以通过node1来访问node2的值，即：node->next->information所指向的datas结构体就是节点2中的信息，同理如果有n个孤立节点依次连接起来，我们就可以通过第一个节点的指针挨个遍历所有节点的信息啦！

1.1.3链表的灵魂——head指针

链表有了节点和连接方式之后，就还差临门一脚了。仿佛此时一个链表类LinkList已经呼之欲出了，但是总觉少了些什么罢，却又是什么呢，我竟答不上来......

究竟少了个啥呢？想想说连接方式里最后说的我们可以通过第一个节点的指针挨个遍历所有节点信息，这个指针就像是所有连接在一起的节点的老大哥一样，所以我们形象的称呼他为老大哥head

显然由于head指向的是链表的第一个节点，所以它的类型是node*，这样我们就得到了LinkList类的雏形：

  1. class LinkList
  2. {
  3.  
  4. private:
  5.     node* head;
  6.  
  7. };

接下来完成以下链表的构造就算是得到了一个初具其形的链表类！

1.1.4链表的构造——带头结点&不带头结点

链表的构造形式有两种：1.带头结点的链表2.不带头结点的链表

它们的区别在于你所感兴趣的信息是从*head结点开始还是(*head->next)结点开始存储。扯白了说就是含有有用信息的结点是从第一个开始捏还是第二个开始捏。

当所感兴趣的信息从(*head->next)结点（也就是第二个结点）开始时第一个结点就只沦为一个指路的工具人，哦不，工具点，此时这个head只用来指路，它带不带信息，带什么信息都雨我无瓜。这便是带头结点的单链表。

当所感兴趣的信息从(*head)结点（也就是第一个结点）开始时，第一个结点便不单单是指路的工具，它所携带的数据*(head->information)同样是俺们感兴趣的玩意。这便是不带头结点的单链表。

此时，最大的区别就体现在二者的长度计算上了，来，康些好康的方便理解：

由于两者在读取信息和计算长度上都有差异，所以添加一个私有成员bool with_head，以此判别是否带头结点！ 

那我们由此可以得出带头结点的构造是非参构造，因为此时head指向的结点的数据信息无关紧要不需要进行人为输入，直接申请一个新结点的空间即可。即:head = new node;

  1. //不带参构造——带头结点的单链表
  2. LinkList()
  3. {
  4.     head = new node;    
  5.     with_head = true;
  6. };

而当我们想要构造不带头结点的单链表时，我们就需要人为地输入一个带有所需信息的结点来初始化head，这便是带参构造（按道理以data作为初始化信息看上去更合理，但是我是懒鬼，所以我的源码里用的是以一个结点指针作为初始化参数的，欸嘿）

版本1——以node*为输入参数

  1. //带参数构造——不带头结点的单链表
  2. LinkList(node* x)
  3. {
  4.     head = x;
  5.     with_head = false;
  6. };

版本2——以datas*为输入参数

  1. //带参数构造——不带头结点的单链表
  2. LinkList(datas* x)
  3. {
  4.     head = new node; //建立一个孤立节点
  5.     head->information = x; //将第一个节点的信息装进去
  6.     with_head = false;
  7. };

至此，我们的LinkList类已经初具其形啦！让我们来康康：

  1. class LinkList
  2. {
  3. public:
  4. 	//无参构造，带头结点的链表
  5. 	LinkList()
  6. 	{
  7. 		head = new node;//给头结点分配内存
  8. 		with_head = true;
  9. 	};
  10.  
  11. 	//带参构造，无头结点的链表
  12. 	LinkList(node* x)
  13. 	{
  14.  
  15. 		head = x;
  16. 		with_head = false;//不带头结点
  17.  
  18. 	};
  19.  
  20. private:
  21. 	node* head;//头节点指针
  22. 	bool with_head;
  23. };

1.1.5编写析构函数（必写）

这是很重要很重要的一步！！！你可能会纳闷在前面构造线性表类SeqList都没提什么析构函数，怎么这里却突然冒出来一个析构函数呢？

因为在编写链表时我们会用到大量的指针，包括在实现一些功能时常常会定义一个孤立节点并给它分配空间拿来使用，如果没有析构函数，这些给出去的内存空间就像嫁出去的媳妇、泼出去的水，不及时清理这些指针就会导致内存泄露！！！

所以我们在析构函数中就一个目的，清除链表中占用的空间，也就是清空链表！由此可见清空链表是一个很重要的功能，我们必须要实现这一功能，假如我们已经通过函数void makeEmpty()实现了这一功能（具体实现见下文），那么析构函数就很好办了：

  1. //析构函数（用于释放内存，防止内存泄露）
  2. ~LinkList()
  3. {
  4. 	makeEmpty();
  5. }

1.2空链表及链表的判空条件

怎样是一个空的链表呢？由于链表的必备元素就一结点指针head，那我们只能由head下手并从此判断，这时细心的你应该注意到了在上文中说过带头结点和不带头结点的单链表在计数上是有差异的，那么自然对于二者的判空也有差异。

什么是空链表呢，咱就是说在这个链表里没有一个结点包含咱想要的信息，这样的链表就叫空链表。

先考虑一手带头结点的链表何时为空：由于带头结点的信息存储是从头结点的下一个结点开始的，那么当头结点的下一个结点不存在时，就称此时的带头结点的链表为空。即：head->next==NULL时为空！

再考虑一手不带头结点的链表何时为空：由于不带头结点的信息存储是从head所指向的结点开始的，那么当head所指向的结点不存在时，就称此时的带头结点的链表为空。即：head==NULL时为空！

也即判空条件可用一个三目运算符表示：(with_head)?head->next==NULL:head==NULL;

于是我们得到了判空函数isEmpty()

  1. bool isEmpty()
  2. {
  3. 	return (with_head) ? head->next == NULL : head == NULL;
  4. }

2.基础功能实现

2.1返回头指针

  1. node* get_head()
  2. {
  3.     return head;
  4. }

2.2返回with_head值（用以外部判断带不带头结点）

  1. bool withHead()
  2. {
  3.     return with_head;
  4. }

2.3返回尾指针

这个实现很容易，但是很实用。尾指针也就是单链表末尾的指针，那不管单链表带不带头结点，它的尾结点均满足一个条件——其所指的下一个结点不存在，也就是node->next==NULL，而这一个结点指针node就是我们要找的尾指针。

再考虑一个特殊情况——当链表尾空，它没有任何连接的结点，那尾结点都不存在何谈尾指针，所以空表时直接返回NULL。

不空的时候我们怎么来找到尾结点呢，我们定义一个结点指针p让它等于head，随后利用while循环只要p不是尾指针（也就是p->next不是NULL），那么p就一直下移，即：p = p->next。

这么一来我们就得到了尾指针的返回函数:

  1. node* last()
  2. {
  3.  
  4.     if (isEmpty())
  5.     {
  6.         return NULL;
  7.     }
  8.  
  9.     node* p = head;
  10.     while ( p->next != NULL )
  11.     {
  12.         p = p->next;
  13.     }
  14.     return p;
  15.  
  16. }

2.4清空链表

想要清空一个链表那么就让它变成空表就好了，先考虑带头结点的情况，此时只需最后使得head->next= NULL并且所有数据节点占用的空间得到释放。

这里注意要让所有数据结点占用的空间得到释放，而遍历链表是从头开始一个一个遍历的，那么想要释放数据结点的空间也就只好一个一个释放过去。

这里我们将清空链表分为4步：

1.建立一个新结点指针p

2.如果head->next != NULL，则将head->next指向下下个

(第二步的实现方法为先用p指向待删结点，也就是p = head->next;然后再将第一个结点与待删节点的下一个结点进行连接，即：head->next = p->next;)

3.释放p的空间

4.重复2、3步直到head->next == NULL（也即此时该带头结点的链表为空）

具体如下图所示：

好了到这里我们就获得了一个清空带头结点的清空函数：

  1. void makeEmpty()
  2. {
  3.  
  4.     node* p;
  5.     while (head->next != NULL)
  6.     {
  7.         p = head->next;
  8.         head->next = p->next;
  9.         delete p;
  10.     }
  11.  
  12. }

那么如果不带头结点怎么办呢，通过上图可以发现删除完之后head所指向的头结点是被保留了的，也就是说当链表不带头结点，我们还要手动删除掉head指向的结点（也就是第一个节点）

即if (!with_head)        head = NULL;

于是，我们得到了完整的makeEmpty()函数：

  1. void makeEmpty()
  2. {
  3.  
  4.     node* p;
  5.     while (head->next != NULL)
  6.     {
  7.         p = head->next;
  8.         head->next = p->next;
  9.         delete p;
  10.     }
  11.  
  12.  
  13.     if (!with_head)
  14.         head = NULL;
  15. }

哈哈哈，写着写着突然清空时发现忽略了一种异常情况——所需清空的已经是空表了，此时应当抛错或者直接return，我比较喜欢抛错。

  1. void makeEmpty()
  2. {
  3.  
  4.     if (isEmpty())
  5.     {
  6.         cout << "空的不能再空啦！" << endl;
  7.         throw 1;
  8.         return;
  9.     }
  10.  
  11.     node* p;
  12.     while (head->next != NULL)
  13.     {
  14.         p = head->next;
  15.         head->next = p->next;
  16.         delete p;
  17.     }
  18.  
  19.  
  20.     if (!with_head)
  21.         head = NULL;
  22. }

2.5链表的长度获取

获取长度的原理十分简单，就是从第一个数据结点开始一直往后遍历，同时记录次数，最后返回次数即可。当然，空表的长度为0，这个情况单独拎出来考虑即可。

关键在第一个数据结点的指针是head还是head->next呢？这时候用三目运算符就好啦，如果是带头结点的那么信息存储结点显然是从head->next开始的，于是得到:

node*p = (with_head) ? head->next : head;

p就是我们遍历的起始指针啦，结束标志自然是当p为尾结点的时候，也就是说初始操作次数初始化为1，因为如果p就是尾结点，那么显然链表长度为1且此时进不了循环。

于是我们得到了长度获取函数length()

  1. int length()
  2. {
  3.     if (isEmpty())
  4.         return 0;
  5.     
  6.     node*p = (with_head) ? head->next : head;
  7.     int count = 1;
  8.     while ( p->next != NULL )
  9.     {
  10.         p = p->next;
  11.         count++;
  12.     }
  13.     return count;
  14. }

2.6输入数据构造链表

这里的构成方法分为两种，一种是前插法，另一种是尾插法。

前插法是指每一个输入数据形成的新节点总是插入在head所指的结点之后。

尾插法是指每一个输入数据形成的新节点总是插在尾结点之后。（这就是为啥要写个last()函数）

那么先来思考一下输入的问题，由于我预先不知道用户需要输入多少个数据，所以我们采用while输入，那么这时候就需要一个结束标志，我们定义一个datas endTag = { 0, "结束" }，也就是当用户输入的数字信息为0并且文字信息为"结束"时我们才结束输入的过程。

注意考虑一个特殊情况，如果用户手贱点开输入，为了退出而直接输入结束标志，此时直接return出去就好了。

  1. void input(datas endTag={ 0, "结束" }, bool front=true)
  2. {
  3.  
  4. 	datas new_data; //用来存储输入的数据
  5.     
  6.     cout << "请输入第一个数据：";
  7. 	cin >> new_data.num;
  8. 	cin >> new_data.intro;
  9.  
  10. 	//直接输入结束符直接开溜
  11. 	if ((new_data.num == endTag.num) && (new_data.intro == endTag.intro))
  12. 	{
  13. 		return;
  14. 	}
  15.  
  16. 	//不满足结束标志则持续输入
  17. 	while ((new_data.num != endTag.num) || (new_data.intro != endTag.intro))
  18. 	{
  19. 		cout << "请输入数据：";
  20. 		cin >> new_data.num;
  21. 		cin >> new_data.intro;
  22. 	}
  23.  
  24.  
  25. }

接着考虑插入问题：由于输入的是datas数据，我们还要将之打包成一个新的结点

构造新节点&保存数据:

  1. node* p = new node; //为新插入的结点申请内存
  2. p->information->num = new_data.num;
  3. p->information->intro = new_data.intro;

前插法： 

将新节点插入头结点后，此时为了保留原本的表链，需要先将新节点的next指向head->next，再将head->next指向新节点。即：

  1. p->next = head->next;
  2. head->next = p;

后插法：

后插法最简单，直接将尾指针的next指向新节点即可：last()->next = p;

这里巧妙在p是无参构造的node，它的next原本就是NULL，恰好与尾结点的定义不谋而合

last()->next = p;

于是咱们就得到了完整的输入函数input()

  1. void input(datas endTag={ 0, "结束" }, bool front=true)
  2. {
  3.  
  4. 	//为新元素申请结点
  5. 	node* p;
  6.  
  7. 	datas* new_data = new datas;
  8.  
  9. 	if (front)//前插法构造链表
  10. 	{
  11. 		cout << "请输入第一个数据：";
  12. 		cin >> new_data->num;
  13. 		cin >> new_data->intro;
  14.  
  15. 		//直接输入结束符，立刻开溜
  16. 		if ((new_data->num == endTag.num) && (new_data->intro == endTag.intro))
  17. 		{
  18. 			return;
  19. 		}
  20.  
  21. 		//不满足结束标志则持续输入
  22. 		while ((new_data->num != endTag.num) || (new_data->intro != endTag.intro))
  23. 		{
  24. 			p = new node;//为新结点申请空间
  25. 			p->information->num = new_data->num;
  26. 			p->information->intro = new_data->intro;
  27. 			if (head->next != NULL)
  28. 			{
  29. 				p->next = head->next;
  30. 			}
  31. 			head->next = p;
  32. 			cout << "请输入数据：";
  33. 			cin >> new_data->num;
  34. 			cin >> new_data->intro;
  35. 		}
  36. 	
  37. 	}
  38.  
  39. 	else//尾插法构造链表
  40. 	{
  41.  
  42. 		cout << "请输入第一个数据：";
  43. 		cin >> new_data->num;
  44. 		cin >> new_data->intro;
  45.  
  46. 		if ((new_data->num == endTag.num) && (new_data->intro == endTag.intro))
  47. 		{
  48. 			return;
  49. 		}
  50.  
  51.  
  52. 		//不满足结束标志则持续输入
  53. 		while ((new_data->num != endTag.num) || (new_data->intro != endTag.intro))
  54. 		{
  55. 			p = new node;//为新结点申请空间
  56. 			p->information->num = new_data->num;
  57. 			p->information->intro = new_data->intro;
  58. 			last()->next = p;
  59. 			cout << "请输入数据：";
  60. 			cin >> new_data->num;
  61. 			cin >> new_data->intro;
  62. 		}
  63.  
  64. 	}
  65.  
  66. }

2.7输出链表

输出一个链表很容易，只要从第一个存有所需信息的结点开始一直遍历并输出下去即可。

但是要注意一个异常，如果为空链表，你可以选择抛错说“空链表无法输出”，也可以输出个“空空如也”啥的，看你自己乐意哪种，我个人倾向于抛错。

只需要注意一点就是开始遍历的结点p应该等于(with_head) ? head->next : head，因为带不带头结点关乎第一个存储信息的结点的位置！

还有一件事！注意这里不是遍历到尾结点就可以跑路的！！！

因为尾结点是含有信息的，所以也要输出，所以结束输出的条件为p == NULL

  1. void output()
  2. {
  3.  
  4. 	if (isEmpty())
  5. 	{
  6. 		cout << "空链表无法输出!" << endl;
  7. 		throw 1;
  8.         return;
  9. 	}
  10.  
  11.     node* p = (with_head) ? head->next : head;
  12.  
  13. 	//带头结点的链表信息输出
  14. 	if (with_head)
  15. 	{
  16. 		p->information = head->next->information;
  17. 		int count = 1;
  18. 		while (p != NULL)
  19. 		{
  20.  
  21. 			cout << "第" << count << "个结点数据信息如下:" << endl;
  22. 			cout << "数字为：" << p->information->num << endl;
  23. 			cout << "信息为：" << p->information->intro << endl;
  24.  
  25. 			count++;
  26. 			p = p->next;
  27.  
  28. 		}
  29. 	}
  30. 	//不带头结点的链表信息输出
  31. 	else
  32. 	{
  33. 		//将初始数据输出
  34. 		cout << "第1" << "个结点数据信息如下:" << endl;
  35. 		cout << "数字为：" << head->information->num << endl;
  36. 		cout << "信息为：" << head->information->intro << endl;
  37. 		p->information = head->next->information;
  38. 		int count = 1;
  39. 		while (p != NULL)
  40. 		{
  41.  
  42. 			cout << "第" << count+1 << "个结点数据信息如下:" << endl;
  43. 			cout << "数字为：" << p->information->num << endl;
  44. 			cout << "信息为：" << p->information->intro << endl;
  45.  
  46. 			count++;
  47. 			p = p->next;
  48.  
  49. 		}
  50. 	}
  51.  
  52. }

3.更多有意思的方法实现

3.1按位查找结点（返回第i个结点的结点指针）

上面实现了一些基操，那么下面再来实现一些有趣的方法，按位查找首当其冲嗷！这个操作很简单，通过上面的方法实现，相信你已经熟练掌握了如何遍历一个链表，那只要在遍历的时候一遍遍历一遍数数，数到i的时候就直接return p;

在开写之前还是先考虑一手异常情况，当i<=0的时候是死都找不到的，直接回NULL（i=0的时候带头结点的可以找到头结点但这没意义所以一并当作异常处理掉！）

于是我们得到了如下代码：

  1. //检查无误！
  2. node* locate(int i)
  3. {
  4. 	
  5. 	//i<=0回空指针
  6. 	if (i <= 0)
  7. 	{
  8. 		return NULL;
  9. 	}
  10.  
  11. 	node* current = head;//当前所在结点指针
  12. 	int k = (with_head) ? 0 : 1;//计数
  13. 	while (current != NULL && k < i)
  14. 	{
  15. 		current = current->next;
  16. 		k++;
  17. 	}
  18. 	return current;
  19.  
  20. }

3.2按值查找（返回其所在结点是第几个）

按位和按值总是被一起提及，那我们也不能棒打鸳鸯，既然写了按位查找，就再写一个按值查找吧！

首先考虑一手异常情况

1.空表，没东西给你找

2.要找的数据压根找不到，返回-1（效仿py哈哈哈）

然后寻找所用的结点指针p初始化时要考虑带不带头结点（用那个三目运算符，老生常谈了属于是）

所以逻辑顺序是

处理异常->找找找（找到了立刻return然后开溜）->找不到（回-1）

  1. int find(datas& x)
  2. {
  3.  
  4. 	node* p = (with_head) ? head->next : head;
  5. 	int i = 1;
  6.  
  7. 	if (isEmpty())
  8. 	{
  9. 		cout << "无数据可供查找！" << endl;
  10. 		throw 2;
  11. 	}
  12.  
  13. 	while ((p->information->num != x.num) || (p->information->intro != x.intro))
  14. 	{
  15. 		if (p->next == NULL)
  16. 			break;
  17. 		p = p->next;
  18. 		i++;
  19. 	}
  20. 	if ((p->information->num == x.num) && (p->information->intro == x.intro))
  21. 	{
  22. 		return i;
  23. 	}
  24. 	
  25. 	//找不到
  26. 	return -1;
  27.  
  28. }

3.3保存第k个结点的信息（需要提供一个datas结构体来存储）

首先看到第k个，马上想到异常——空表和当k溢出范围，即当k不属于区间[1,length]

那如果k合法且表不空呢？该如何存储数据呢？

很简单嘛，用3.1实现的locate方法，locate(i)返回的是第i个结点的地址信息那我们通过对它所指向的结构体指针infromation取个址就得到了所需数据datas啦！

于是得到下面的代码：

  1. void save_data(int k, datas& saved)
  2. {
  3.  
  4. 	if (isEmpty())
  5. 	{
  6. 		cout << "鬼！这里没东西可存！" << endl;
  7. 		throw 1;
  8.         return;
  9. 	}
  10.  
  11. 	else if (k < 0 || k > length())
  12. 	{
  13. 		cout << "所给下标溢出范围" << endl;
  14. 		throw 2;
  15.         return;
  16. 	}
  17.  
  18. 	else
  19. 	{
  20.         saved = *(locate(k)->information);
  21. 	}
  22.  
  23. }

3.4按位删除结点

接下来实现一手按位删除元素的操作，还记得之前写清空链表时的操作嘛？要删掉一个结点很简单，找到它上一个结点并将他先连接到下下个结点，再杀掉当前的待删结点。

而待删结点前一个结点怎么获得呢？欸嘿，直接locate(k-1)

异常处理和按位寻找一样，所以直接上代码：

  1. datas remove(int k)
  2. {
  3.     //异常处理
  4.     if(k<1 || k>length())
  5.     {
  6.         cout << "下标不合法！" << endl;
  7.         throw 1;
  8.     }
  9.     if (isEmpty())
  10. 	{
  11. 		cout << "所要移去的结点为空结点" << endl;
  12. 		throw 1;
  13. 	}
  14. 	node* p = locate(k - 1);
  15. 	node* del = p->next; //被删除的结点的指针
  16. 	p->next = del->next;
  17. 	datas* save = new datas;
  18. 	save->num = del->information->num;
  19. 	save->intro = del->information->intro;
  20. 	delete del;
  21.  
  22. 	return *save;
  23. }

3.5按值删除

按值删除只需要先处理异常，然后通过前面实现的find方法获取待删下标，再按位删除就好啦！

代码如下：

  1. datas remove_num(int num)
  2. {
  3.     if(isEmpty())
  4.     {
  5.         cout << "空表无法进行remove操作" << endl;
  6.         throw 1;
  7.     }
  8.     int index = find(num);
  9.     
  10.     if (index == -1)
  11.     {
  12.         return;
  13.     }
  14.     
  15.     return remove(index);
  16. }

3.6翻转链表

想要翻转一个链表可以怎么做捏？我想到的方法是：

1.先把尾结点挪到第一个数据结点前，并记录这个被挪动的结点指针end

2.不断将尾结点挪动到end所指的结点上，并刷新end

3.重复第二步直到第一个数据点的next指向NULL

具体如下图：

 上图考虑的是带头结点的情况，此时不难发现只要将head->next指向end就完成了翻转

那么如果不带头结点呢？那只要把head指向end就好了，因为end指向的是翻转后的第一个数据结点。

于是我们得到了如下代码：

  1. //翻转链表
  2. void reverse()
  3. {
  4.  
  5. 	if (isEmpty())
  6. 	{
  7.  
  8. 		cout << "空表无法反转！" << endl;
  9. 		throw 1;
  10. 		return;
  11.  
  12. 	}
  13.  
  14. 	node* start = (withHead()) ? head->next : head;
  15. 	node* end = last();
  16. 	node* pre = start;
  17. 	//翻转
  18. 	while (start->next != NULL)
  19. 	{
  20. 		//暂时储存下一节点的next信息
  21. 		node* temp = start->next->next;
  22. 		//下一节点的next接到前一结点
  23. 		start->next->next = pre;
  24. 		//储存前一结点信息以便下一次拼接
  25. 		pre = start->next;
  26. 		//当前结点的next后跳一位
  27. 		start->next = temp;
  28.  
  29. 	}
  30.  
  31. 	//重新赋值head
  32. 	if (withHead())
  33. 	{
  34. 		//有头指针时，反转后将头结点指向end
  35. 		head->next = end;
  36. 	}
  37. 	else
  38. 	{
  39. 		//无头指针时，翻转后只需要把end赋给head
  40. 		head = end;
  41. 	}
  42.  
  43. }

4.插值

因为插值是我作业的重点任务，所以单独拎出来说说，而且链表的插值还要判别下单调性啥的，还蛮有意思。

4.1按位插入

到了这个地步，按位插入拆分成按位和插入的话只需要解决后者了，因为找到该插入的结点可以直接locate一手，欸嘿！

那我们只要明确一下插入的逻辑，想将datas的数据插入第k个结点，那也就是相当于原来的第k-1个结点要与新结点连接并且新节点的next指向原第k个结点。

封装成新节点十分简单：

  1. node* p = new node;
  2. *(p->information) = ins_data;//ins_data为输入的要插入的数据

如果新节点指针为p，那么上述逻辑写成代码就是：

  1. node* current = locate(k-1);
  2. p->next = current->next;
  3. current->next = p;

 于是我们得到了按位插入方法：

  1. void insert(datas ins_data, int k)
  2. {
  3. 	node* current = locate(k - 1);
  4. 	node* p = new node;//插入结点
  5. 	//将插入数据放入插入节点
  6. 	p->information->intro = ins_data.intro;
  7. 	p->information->num = ins_data.num;
  8.  
  9. 	//插入结点
  10. 	p->next = current->next;
  11. 	current->next = p;
  12. }

4.2单调性判别

看着这个标题直接梦回大一学高数那会哈哈！在线性表那我有说过按值插入的前提是序列有序，那么在进行按值插入前我们就得先完成一个用来甄别链表是否具有有序性的方法。

首先确定函数类型，由于单调性有三种情况——1.无单调性2.递增3.递减

所以简单的bool型已经无法满足我们的需求，所以我选择采用整形，返回值为0代表无单调性，1代表递增，2代表递减。

首先考虑特殊情况——1.空表（无单调性）2.长度为1的链表（这个情况的处理我直接当成递增了）

于是得到以下代码：

  1. if (isEmpty())
  2. {
  3. 	cout << "空表无单调性！" << endl;
  4. 	return 0;
  5. }
  6.  
  7. if (length() == 1)
  8. {
  9. 	return 1;
  10. }

接着来做初始化，有两个东西得初始化，第一个自然是老生常谈的结点指针p，因为判断单调性从有数据的结点开始就好了所以node* p = (with_head) ? head->next : head;

第二个则是判断一开始的单调性（通过判断第一个和第二个的大小来获得初始单调性）

int sign = (p->information->num < p->next->information->num) ? 1 : 2;//1增2减

接着便是遍历链表，看之后的大小关系是否会打脸sign初始值，即如果第一个节点的num比第二个的大，那初始单调性是递增，如果后来出现一个结点的num值反倒小于后一个结点的num则属于是打脸了，一打脸就代表该链表没得单调性，直接return 0;

  1. //判断是否具有单调性
  2. switch (sign)
  3. {
  4. case 1://递增
  5. 	while (p->next != NULL)
  6. 	{
  7. 		if (p->information->num > p->next->information->num)
  8. 		{
  9. 			return 0;
  10. 		}
  11. 		p = p->next;
  12. 	}
  13. 	return 1;
  14. 	break;
  15. case 2://递减
  16. 	while (p->next != NULL)
  17. 	{
  18. 		if (p->information->num < p->next->information->num)
  19. 		{
  20. 			return 0;
  21. 		}
  22. 		p = p->next;
  23. 	}
  24. 	return 2;
  25. 	break;
  26. default:
  27. 	return 0;
  28. 	break;
  29. }

至此我们便获得了一个用于判断单调性的函数：

  1. int single()
  2. {
  3.  
  4. 	if (isEmpty())
  5. 	{
  6. 		cout << "空表无单调性！" << endl;
  7. 		return 0;
  8. 	}
  9.  
  10. 	node* p = (withHead()) ? head->next : head;
  11. 	if (length() == 1)
  12. 	{
  13. 		return 1;
  14. 	}
  15. 	int sign = (p->information->num < p->next->information->num) ? 1 : 2;//1增2减
  16. 	
  17. 	//判断是否具有单调性
  18. 	switch (sign)
  19. 	{
  20. 	case 1://递增
  21. 		while (p->next != NULL)
  22. 		{
  23. 			if (p->information->num > p->next->information->num)
  24. 			{
  25. 				return 0;
  26. 			}
  27. 			p = p->next;
  28. 		}
  29. 		return 1;
  30. 		break;
  31. 	case 2://递减
  32. 		while (p->next != NULL)
  33. 		{
  34. 			if (p->information->num < p->next->information->num)
  35. 			{
  36. 				return 0;
  37. 			}
  38. 			p = p->next;
  39. 		}
  40. 		return 2;
  41. 		break;
  42. 	default:
  43. 		return 0;
  44. 		break;
  45. 	}
  46. }

4.3按值插入

有了上述两个方法就很好办啦！逻辑也很简单：

先判断该链表有没有单调性，没有的话没法按值插入

有单调性则先比较两头，比较一头一尾，因为按位插入基于locate方法，所以没法将待插结点变成头或尾。

所以对先将一头一尾与待插数据进行大小比较，插头插尾拎出来考虑。

该插入的地方既不在头也不在尾则遍历链表寻找合适的index，这里注意如果待插结点在第i个结点和第i+1个结点符合递变规律，那么应该让它成为新的第i+1个结点，即insert(ins_data, index+1)

于是我们得到了按值插入函数:

  1. void insert(datas ins_data)
  2. {
  3. 	//初始化为第一个有信息结点用来判断特殊情况
  4. 	node* p = (withHead()) ? head->next : head;
  5. 	int index = 1;//当前处于第一个结点
  6. 	switch (single())
  7. 	{
  8. 	case 0://无序时抛错
  9. 		cout << "该链表数字排列无序，无法按值插入！" << endl;
  10. 		throw 1;
  11. 		return;
  12. 		break;
  13. 	case 1://递增排列
  14. 		//比第一个还小就插在第一个
  15. 		if (ins_data.num <= p->information->num)
  16. 		{
  17. 			insert(ins_data, 1);
  18. 		}
  19. 		//比最后一个还大就插在尾
  20. 		else if (ins_data.num >= last()->information->num)
  21. 		{
  22. 			node* ins_node = new node;
  23. 			//插入值赋给插入节点
  24. 			*(ins_node->information) = ins_data;
  25. 			last()->next = ins_node;//插入尾结点后
  26. 		}
  27. 		//不然就寻找合适的位置下标index
  28. 		else
  29. 		{
  30. 			while (1)
  31. 			{
  32. 				if (ins_data.num >= p->information->num && //比这一个大
  33. 					ins_data.num <= p->next->information->num)//比下一个小
  34. 				{
  35. 					insert(ins_data, index + 1);
  36. 					break;
  37. 				}//循环边界，当ins_data.num在第index和第index+1数据之间则插成第index+1个
  38. 				p = p->next;
  39. 				index++;
  40. 			}
  41. 		}
  42. 		break;
  43. 	case 2://递减排列
  44. 		//比第一个还大就插在第一个
  45. 		if (ins_data.num >= p->information->num)
  46. 		{
  47. 			insert(ins_data, 1);
  48. 		}
  49. 		//比最后一个还小就插在尾
  50. 		else if (ins_data.num <= last()->information->num)
  51. 		{
  52. 			node* ins_node = new node;
  53. 			//插入值赋给插入节点
  54. 			*(ins_node->information) = ins_data;
  55. 			last()->next = ins_node;//插入尾结点后
  56. 		}
  57. 		//不然就寻找合适的位置下标index
  58. 		else
  59. 		{
  60. 			while (1)
  61. 			{
  62. 				if (ins_data.num <= p->information->num && //比这一个小
  63. 					ins_data.num >= p->next->information->num)//比下一个大
  64. 				{
  65. 					insert(ins_data, index + 1);
  66. 					break;
  67. 				}//循环边界，当ins_data.num在第index和第index+1数据之间则插成第index+1个
  68. 				p = p->next;
  69. 				index++;
  70. 			}
  71. 		}
  72. 		break;
  73. 		break;
  74. 	default:
  75. 		break;
  76. 	}
  77.  
  78. }

4.4改进按位插入

通过4.3发现之前的按位插入漏掉了一头一尾两种情况

如果要插入最头上还应分成是否带有头结点来考虑，即：

  1. if (k == 1)//要插成第一个
  2. {
  3. 	if (with_head)
  4. 	{
  5. 		p->next = head->next;
  6. 		head->next = p;
  7. 	}
  8.  
  9. 	else
  10. 	{
  11. 		p->next = head;
  12. 		head = p;
  13. 	}
  14. }

插成尾就比较简单，直接:

last()->next = p;

即可，所以改进后的按位插入函数为：

  1. void insert(datas ins_data, int k)
  2. {
  3. 	node* p = new node;//插入结点
  4. 	//将插入数据放入插入节点
  5. 	p->information->intro = ins_data.intro;
  6. 	p->information->num = ins_data.num;
  7.  
  8. 	if (k == 1)//要插成第一个
  9. 	{
  10. 		if (with_head)
  11. 		{
  12. 			p->next = head->next;
  13. 			head->next = p;
  14. 		}
  15.  
  16. 		else
  17. 		{
  18. 			p->next = head;
  19. 			head = p;
  20. 		}
  21. 	}
  22.  
  23. 	else if (k == length() + 1)//代表成为新尾结点
  24. 	{
  25. 		last()->next = p;
  26. 	}
  27.  
  28. 	node* current = locate(k - 1);
  29.  
  30. 	//插入结点
  31. 	p->next = current->next;
  32. 	current->next = p;
  33. }

5.一些测试函数（自己调试的时候写的）

5.1方法函数测试

  1. void Func_test()
  2. {
  3. 	LinkList L1;
  4. 	L1.input();
  5. 	L1.output();
  6. 	cout << L1.isEmpty() << endl;
  7. 	cout << L1.length() << endl;
  8. 	datas d = { 2, "b" };
  9. 	cout << L1.find(d) << endl;
  10. 	if (L1.locate(L1.find(d))->information->num == 2)
  11. 	{
  12. 		cout << "locate函数检查无误！" << endl;
  13. 	}
  14. 	else
  15. 	{
  16. 		cout << "locate函数有误！" << endl;
  17. 	}
  18. 	cout << "尾部数字为：" << L1.last()->information->num << endl;
  19.  
  20. 	//检查单调性
  21. 	if (L1.single() == 0)
  22. 	{
  23. 		cout << "无单调性" << endl;
  24. 	}
  25. 	else
  26. 	{
  27. 		string dd_str = (L1.single() == 1) ? "递增" : "递减";
  28. 		cout << dd_str << endl;
  29. 	}
  30.  
  31. 	//检查按值插入
  32. 	datas insert_data = { 2, "被按值插入的数字" };
  33. 	L1.insert(insert_data, L1.withHead());
  34. 	L1.output();
  35.  
  36. 	//检查按位插入
  37. 	insert_data = { 0, "被按位插入的数字" };
  38. 	L1.insert(insert_data, 1);
  39. 	L1.output();
  40.  
  41. 	//检查remove
  42. 	datas rem, temp;//用来储存被删除的结点信息
  43. 	int length = L1.length();
  44. 	temp = *(L1.locate(1)->information);
  45. 	rem = L1.remove(1);
  46. 	int length_ = L1.length();
  47. 	if (length_ == length - 1 && rem.num == temp.num && rem.intro == temp.intro)
  48. 	{
  49. 		cout << "remove函数检查无误！" << endl;
  50. 	}
  51. 	else
  52. 	{
  53. 		cout << "remove函数出问题咯！" << endl;
  54. 	}
  55.  
  56. 	//翻转
  57. 	L1.reverse();
  58. 	L1.output();
  59.  
  60. 	//检查makeEmpty
  61. 	L1.makeEmpty();
  62. 	string mE_ass_err = (L1.length() == 0) ? "makeEmpty函数正确无误！" : 
  63. 		"makeEmpty函数有问题";
  64. 	cout << mE_ass_err << endl;
  65.  
  66. }

5.2带头结点链表测试

  1. void head_display()
  2. {
  3. 	LinkList L1;
  4. 	L1.input();
  5. 	L1.output();
  6. 	cout << L1.isEmpty() << endl;
  7. 	cout << L1.length() << endl;
  8. 	datas d = { 2, "b" };
  9. 	cout << L1.find(d) << endl;
  10. 	if (L1.locate(L1.find(d))->information->num == 2)
  11. 	{
  12. 		cout << "locate函数检查无误！" << endl;
  13. 	}
  14. 	else
  15. 	{
  16. 		cout << "locate函数有误！" << endl;
  17. 	}
  18. 	cout << "尾部数字为：" << L1.last()->information->num << endl;
  19.  
  20. 	//检查单调性
  21. 	if (L1.single() == 0)
  22. 	{
  23. 		cout << "无单调性" << endl;
  24. 	}
  25. 	else
  26. 	{
  27. 		string dd_str = (L1.single() == 1) ? "递增" : "递减";
  28. 		cout << dd_str << endl;
  29. 	}
  30.  
  31. 	//检查按值插入
  32. 	datas insert_data = { 30, "被插入的数字" };
  33. 	L1.insert(insert_data);
  34. 	L1.output();
  35.  
  36. 	//检查按位插入
  37. 	insert_data = { 2, "被插入的数字" };
  38. 	L1.insert(insert_data, 1);
  39. 	L1.output();
  40.  
  41. 	//检查save_data
  42. 	datas save_data;
  43. 	L1.save_data(3, save_data);
  44. 	cout << "--------被保存的是第三个结点，信息如下----------" << endl;
  45. 	cout << "num：" << save_data.num << endl;
  46. 	cout << "intro：" << save_data.intro << endl;
  47.  
  48. 	datas remove_data = L1.remove(2);
  49. 	L1.output();
  50. 	cout << "------被删除的结点信息如下--------" << endl;
  51. 	cout << "num：" << remove_data.num << endl;
  52. 	cout << "intro：" << remove_data.intro << endl;
  53.  
  54. 	//翻转演示
  55. 	L1.reverse();
  56. 	cout << "------翻转后的链表信息如下--------" << endl;
  57. 	L1.output();
  58.  
  59. 	//清空检查
  60. 	L1.makeEmpty();
  61. 	cout << "清空后链表长度为：" << L1.length() << endl;
  62.  
  63. }

5.3不带头结点链表测试

  1. void nohead_display()
  2. {
  3. 	datas* init_data = new datas;
  4. 	*init_data = { 0, "初始结点" };
  5. 	node* init_node = new node;
  6. 	init_node->information = init_data;
  7.  
  8. 	//构造无头结点的链表
  9. 	LinkList L1(init_node);
  10. 	L1.input();
  11. 	L1.output();
  12. 	cout << "第2个结点数字为" << L1.locate(2)->information->num << endl;
  13.  
  14. 	cout << "------长度如下------" << endl;
  15. 	cout << L1.length() << endl;
  16.  
  17. 	//按位插值检验
  18. 	datas ins_data = { 10, "被插入的结点" };
  19. 	L1.insert(ins_data, 2);
  20. 	L1.output();
  21.  
  22. 	//按位删除检查
  23. 	datas remove_data = L1.remove(2);
  24. 	L1.output();
  25. 	cout << "------被删除的结点信息如下--------" << endl;
  26. 	cout << "num：" << remove_data.num << endl;
  27. 	cout << "intro：" << remove_data.intro << endl;
  28.  
  29. 	//单调性检查
  30. 	if (L1.single() == 0)
  31. 	{
  32. 		cout << "无单调性" << endl;
  33. 	}
  34. 	else
  35. 	{
  36. 		string ddx = (L1.single() == 1) ? "递增" : "递减";
  37. 		cout << ddx << endl;
  38. 	}
  39.  
  40. 	//按值插入检查
  41. 	ins_data = { 15, "被插入的结点" };
  42. 	L1.insert(ins_data, L1.withHead());
  43. 	L1.output();
  44.  
  45. 	//翻转演示
  46. 	L1.reverse();
  47. 	cout << "------翻转后的链表信息如下--------" << endl;
  48. 	L1.output();
  49.  
  50. }

6.LinkList类整合

  1. class LinkList
  2. {
  3. public:
  4. 	//无参构造，带头结点的链表
  5. 	LinkList()
  6. 	{
  7. 		head = new node;//给头结点分配内存
  8. 		with_head = true;
  9. 	};
  10.  
  11. 	//带参构造，无头结点的链表
  12. 	LinkList(node* x)
  13. 	{
  14.  
  15. 		head = x;
  16. 		with_head = false;//不带头结点
  17.  
  18. 	};
  19.  
  20.     //析构函数（用于释放内存，防止内存泄露）
  21.     ~LinkList()
  22.     {
  23. 	    makeEmpty();
  24.     }
  25.  
  26.     bool isEmpty()
  27.     {
  28. 	    return (with_head) ? head->next == NULL : head == NULL;
  29.     }
  30.  
  31.     node* get_head()
  32.     {
  33.         return head;
  34.     }
  35.     
  36.     bool withHead()
  37.     {
  38.         return with_head;
  39.     }
  40.  
  41.     node* last()
  42.     {
  43.  
  44.         if (isEmpty())
  45.         {
  46.             return NULL;
  47.         }
  48.  
  49.         node* p = head;
  50.         while ( p->next != NULL )
  51.         {
  52.             p = p->next;
  53.         }
  54.         return p;
  55.  
  56.     }
  57.     
  58.     void makeEmpty()
  59.     {
  60.  
  61.         if (isEmpty())
  62.         {
  63.             cout << "空的不能再空啦！" << endl;
  64.             throw 1;
  65.             return;
  66.         }
  67.  
  68.         node* p;
  69.         while (head->next != NULL)
  70.         {
  71.             p = head->next;
  72.             head->next = p->next;
  73.             delete p;
  74.         }
  75.  
  76.  
  77.         if (!with_head)
  78.             head = NULL;
  79.     }
  80.  
  81.     int length()
  82.     {
  83.         if (isEmpty())
  84.             return 0;
  85.     
  86.         node*p = (with_head) ? head->next : head;
  87.         int count = 1;
  88.         while ( p->next != NULL )
  89.         {
  90.             p = p->next;
  91.             count++;
  92.         }
  93.         return count;
  94.     }    
  95.  
  96.     void input(datas endTag={ 0, "结束" }, bool front=true)
  97.     {
  98.  
  99. 	    //为新元素申请结点
  100. 	    node* p;
  101.  
  102. 	    datas* new_data = new datas;
  103.  
  104. 	    if (front)//前插法构造链表
  105.     	{
  106. 	    	cout << "请输入第一个数据：";
  107. 	    	cin >> new_data->num;
  108. 	    	cin >> new_data->intro;
  109.  
  110. 		    //直接输入结束符，立刻开溜
  111. 		    if ((new_data->num == endTag.num) && (new_data->intro == endTag.intro))
  112. 		    {
  113. 		    	return;
  114. 		    }
  115.  
  116. 		    //不满足结束标志则持续输入
  117. 		    while ((new_data->num != endTag.num) || (new_data->intro != endTag.intro))
  118. 		    {
  119. 		    	p = new node;//为新结点申请空间
  120. 		    	p->information->num = new_data->num;
  121. 		    	p->information->intro = new_data->intro;
  122. 		    	if (head->next != NULL)
  123. 		    	{
  124. 		    		p->next = head->next;
  125. 		    	}
  126. 		    	head->next = p;
  127. 		    	cout << "请输入数据：";
  128. 		    	cin >> new_data->num;
  129. 		    	cin >> new_data->intro;
  130. 		    }
  131. 	
  132. 	    }
  133.  
  134. 	    else//尾插法构造链表
  135. 	    {
  136.  
  137. 		    cout << "请输入第一个数据：";
  138. 		    cin >> new_data->num;
  139. 		    cin >> new_data->intro;
  140.  
  141. 		    if ((new_data->num == endTag.num) && (new_data->intro == endTag.intro))
  142. 		    {
  143. 		    	return;
  144. 		    }
  145.  
  146.  
  147. 		    //不满足结束标志则持续输入
  148. 		    while ((new_data->num != endTag.num) || (new_data->intro != endTag.intro))
  149. 		    {
  150. 			    p = new node;//为新结点申请空间
  151. 			    p->information->num = new_data->num;
  152. 			    p->information->intro = new_data->intro;
  153. 			    last()->next = p;
  154. 			    cout << "请输入数据：";
  155. 		       	cin >> new_data->num;
  156. 		    	cin >> new_data->intro;
  157. 		    }
  158.  
  159. 	    }
  160.  
  161.     }
  162.  
  163.     void output()
  164.     {
  165.  
  166. 	    if (isEmpty())
  167. 	    {
  168. 	    	cout << "空链表无法输出!" << endl;
  169. 	    	throw 1;
  170.             return;
  171. 	    }
  172.  
  173.         node* p = (with_head) ? head->next : head;
  174.  
  175. 	    //带头结点的链表信息输出
  176. 	    if (with_head)
  177. 	    {
  178. 		    p->information = head->next->information;
  179. 		    int count = 1;
  180. 		    while (p != NULL)
  181. 		    {
  182.  
  183. 			    cout << "第" << count << "个结点数据信息如下:" << endl;
  184. 			    cout << "数字为：" << p->information->num << endl;
  185. 			    cout << "信息为：" << p->information->intro << endl;
  186.  
  187. 		    	count++;
  188. 		    	p = p->next;
  189.     
  190. 	        }
  191.     	}
  192. 	    //不带头结点的链表信息输出
  193. 	    else
  194.     	{
  195. 		    //将初始数据输出
  196. 		    cout << "第1" << "个结点数据信息如下:" << endl;
  197. 		    cout << "数字为：" << head->information->num << endl;
  198. 		    cout << "信息为：" << head->information->intro << endl;
  199. 		    p->information = head->next->information;
  200. 		    int count = 1;
  201. 		    while (p != NULL)
  202. 		    {
  203.  
  204. 			    cout << "第" << count+1 << "个结点数据信息如下:" << endl;
  205. 			    cout << "数字为：" << p->information->num << endl;
  206. 			    cout << "信息为：" << p->information->intro << endl;
  207.  
  208. 		    	count++;
  209. 		    	p = p->next;
  210.  
  211. 		    }
  212. 	    }
  213.  
  214.     }
  215.  
  216.     //检查无误！
  217.     node* locate(int i)
  218.     {
  219. 	
  220. 	    //i<=0回空指针
  221. 	    if (i <= 0)
  222. 	    {
  223. 	    	return NULL;
  224. 	    }
  225.  
  226. 	    node* current = head;//当前所在结点指针
  227. 	    int k = (with_head) ? 0 : 1;//计数
  228. 	    while (current != NULL && k < i)
  229. 	    {
  230. 	    	current = current->next;
  231. 	    	k++;
  232. 	    }
  233. 	    return current;
  234.  
  235.     }
  236.  
  237.     int find(datas& x)
  238.     {
  239.  
  240. 	    node* p = (with_head) ? head->next : head;
  241. 	    int i = 1;
  242.  
  243. 	    if (isEmpty())
  244. 	    {
  245. 	    	cout << "无数据可供查找！" << endl;
  246. 	    	throw 2;
  247. 	    }
  248.  
  249. 	    while ((p->information->num != x.num) || (p->information->intro != x.intro))
  250. 	    {
  251. 		    if (p->next == NULL)
  252. 		    	break;
  253. 		    p = p->next;
  254. 	    	i++;
  255. 	    }
  256. 	    if ((p->information->num == x.num) && (p->information->intro == x.intro))
  257. 	    {
  258. 	        return i;
  259. 	    }
  260. 	
  261. 	    //找不到
  262. 	    return -1;
  263.  
  264.     }
  265.  
  266.     void save_data(int k, datas& saved)
  267.     {
  268.  
  269. 	    if (isEmpty())
  270. 	    {
  271. 	    	cout << "鬼！这里没东西可存！" << endl;
  272. 	    	throw 1;
  273.             return;
  274. 	    }
  275.     
  276. 	    else if (k < 0 || k > length())
  277. 	    {
  278. 		    cout << "所给下标溢出范围" << endl;
  279. 	    	throw 2;
  280.             return;
  281. 	    }
  282.     
  283. 	    else
  284. 	    {
  285.             saved = *(locate(k)->information);
  286. 	    }
  287.  
  288.     }
  289.  
  290.     datas remove(int k)
  291.     {
  292.         //异常处理
  293.         if(k<1 || k>length())
  294.         {
  295.             cout << "下标不合法！" << endl;
  296.             throw 1;
  297.         }
  298.         if (isEmpty())
  299. 	    {
  300. 	    	cout << "所要移去的结点为空结点" << endl;
  301. 	    	throw 1;
  302. 	    }
  303. 	    node* p = locate(k - 1);
  304. 	    node* del = p->next; //被删除的结点的指针
  305. 	    p->next = del->next;
  306. 	    datas* save = new datas;
  307. 	    save->num = del->information->num;
  308. 	    save->intro = del->information->intro;
  309. 	    delete del;
  310.  
  311.     	return *save;
  312.     }
  313.  
  314.     datas remove_num(int num)
  315.     {
  316.         if(isEmpty())
  317.         {
  318.             cout << "空表无法进行remove操作" << endl;
  319.             throw 1;
  320.         }
  321.         int index = find(num);
  322.     
  323.         if (index == -1)
  324.         {
  325.             return;
  326.         }
  327.     
  328.         return remove(index);
  329.     } 
  330.  
  331.     //翻转链表
  332.     void reverse()
  333.     {
  334.  
  335. 	    if (isEmpty())
  336. 	    {
  337.  
  338. 	    	cout << "空表无法反转！" << endl;
  339. 	    	throw 1;
  340. 	    	return;
  341.  
  342. 	    }
  343.  
  344. 	    node* start = (withHead()) ? head->next : head;
  345. 	    node* end = last();
  346. 	    node* pre = start;
  347. 	    //翻转
  348. 	    while (start->next != NULL)
  349. 	    {
  350. 		    //暂时储存下一节点的next信息
  351. 		    node* temp = start->next->next;
  352. 		    //下一节点的next接到前一结点
  353. 	    	start->next->next = pre;
  354. 	    	//储存前一结点信息以便下一次拼接
  355. 	    	pre = start->next;
  356. 		    //当前结点的next后跳一位
  357. 	    	start->next = temp;
  358.  
  359. 	    }
  360.  
  361. 	    //重新赋值head
  362. 	    if (withHead())
  363. 	    {
  364. 	    	//有头指针时，反转后将头结点指向end
  365. 	    	head->next = end;
  366. 	    }
  367. 	    else
  368. 	    {
  369. 	    	//无头指针时，翻转后只需要把end赋给head
  370. 	    	head = end;
  371. 	    }
  372.  
  373.     }
  374.  
  375.     int single()
  376.     {
  377.  
  378. 	    if (isEmpty())
  379. 	    {
  380. 	    	cout << "空表无单调性！" << endl;
  381. 	    	return 0;
  382. 	    }
  383.  
  384. 	    node* p = (withHead()) ? head->next : head;
  385. 	    if (length() == 1)
  386. 	    {
  387. 		    return 1;
  388. 	    }
  389. 	    int sign = (p->information->num < p->next->information->num) ? 1 : 2;//1增2减
  390. 	
  391. 	    //判断是否具有单调性
  392. 	    switch (sign)
  393. 	    {
  394. 	    case 1://递增
  395. 		    while (p->next != NULL)
  396. 	    	{
  397. 		    	if (p->information->num > p->next->information->num)
  398. 		    	{
  399. 		    		return 0;
  400. 		    	}
  401. 		    	p = p->next;
  402. 	    	}
  403. 	    	return 1;
  404. 	    	break;
  405. 	    case 2://递减
  406. 		    while (p->next != NULL)
  407. 		    {
  408. 		    	if (p->information->num < p->next->information->num)
  409. 			    {
  410. 			    	return 0;
  411. 		    	}
  412. 		    	p = p->next;
  413. 	    	}
  414. 	    	return 2;
  415. 	    	break;
  416. 	    default:
  417. 	    	return 0;
  418. 	    	break;
  419. 	    }
  420.     }
  421.  
  422.     void insert(datas ins_data, int k)
  423.     {
  424. 	    node* p = new node;//插入结点
  425. 	    //将插入数据放入插入节点
  426.     	p->information->intro = ins_data.intro;
  427. 	    p->information->num = ins_data.num;
  428.  
  429. 	    if (k == 1)//要插成第一个
  430.     	{
  431. 		    if (with_head)
  432. 		    {
  433. 	    		p->next = head->next;
  434. 	    		head->next = p;
  435. 	    	}
  436.  
  437. 	    	else
  438. 	    	{
  439. 	    		p->next = head;
  440. 	    		head = p;
  441. 	    	}
  442. 	    }
  443.  
  444. 	    else if (k == length() + 1)//代表成为新尾结点
  445. 	    {
  446. 	    	last()->next = p;
  447. 	    }
  448.     
  449. 	    node* current = locate(k - 1);
  450.  
  451. 	    //插入结点
  452. 	    p->next = current->next;
  453. 	    current->next = p;
  454.     }
  455.  
  456.     void insert(datas ins_data)
  457.     {
  458. 	    //初始化为第一个有信息结点用来判断特殊情况
  459. 	    node* p = (withHead()) ? head->next : head;
  460. 	    int index = 1;//当前处于第一个结点
  461. 	    switch (single())
  462.     	{
  463. 	    case 0://无序时抛错
  464. 	    	cout << "该链表数字排列无序，无法按值插入！" << endl;
  465. 	    	throw 1;
  466. 		    return;
  467. 		    break;
  468. 	    case 1://递增排列
  469. 	    	//比第一个还小就插在第一个
  470. 	    	if (ins_data.num <= p->information->num)
  471. 	    	{
  472. 		    	insert(ins_data, 1);
  473. 	    	}
  474. 		    //比最后一个还大就插在尾
  475. 		    else if (ins_data.num >= last()->information->num)
  476. 		    {
  477. 		    	node* ins_node = new node;
  478. 		    	//插入值赋给插入节点
  479. 		    	*(ins_node->information) = ins_data;
  480. 		    	last()->next = ins_node;//插入尾结点后
  481. 		    }
  482. 		    //不然就寻找合适的位置下标index
  483. 		    else
  484. 		    {
  485. 		    	while (1)
  486. 		    	{
  487. 			    	if (ins_data.num >= p->information->num && //比这一个大
  488. 				    	ins_data.num <= p->next->information->num)//比下一个小
  489. 			    	{
  490. 				    	insert(ins_data, index + 1);
  491. 				    	break;
  492. 				    }//循环边界，当ins_data.num在第index和第index+1数据之间则插成第index+1个
  493. 			    	p = p->next;
  494. 			    	index++;
  495. 		    	}
  496. 	    	}
  497. 		    break;
  498. 	    case 2://递减排列
  499. 		    //比第一个还大就插在第一个
  500. 	    	if (ins_data.num >= p->information->num)
  501. 	    	{
  502. 	    		insert(ins_data, 1);
  503. 		    }
  504. 		    //比最后一个还小就插在尾
  505. 		    else if (ins_data.num <= last()->information->num)
  506. 		    {
  507. 		    	node* ins_node = new node;
  508. 		    	//插入值赋给插入节点
  509. 		    	*(ins_node->information) = ins_data;
  510. 		    	last()->next = ins_node;//插入尾结点后
  511. 		    }
  512. 		    //不然就寻找合适的位置下标index
  513. 		    else
  514. 		    {
  515. 			    while (1)
  516. 			    {
  517. 				    if (ins_data.num <= p->information->num && //比这一个小
  518. 				    	ins_data.num >= p->next->information->num)//比下一个大
  519. 				    {
  520. 				    	insert(ins_data, index + 1);
  521. 				    	break;
  522. 				    }//循环边界，当ins_data.num在第index和第index+1数据之间则插成第index+1个
  523. 			    	p = p->next;
  524. 			    	index++;
  525. 			    }
  526. 	    	}
  527. 	    	break;
  528. 	    default:
  529. 	    	break;
  530.     	}
  531.  
  532.     }
  533.  
  534. private:
  535. 	node* head;//头节点指针
  536. 	bool with_head;
  537. };

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/703441
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号