《9.链表&状态机与多线程》

转自 https://edu.csdn.net/lecturer/505 朱老师物联网大讲堂
《9.链表&状态机与多线程》

第一部分、章节目录
4.9.1.链表的引入
4.9.2.单链表的实现
4.9.3.单链表的算法之插入节点
4.9.4.单链表的算法之插入节点续
4.9.5.从链表头部插入新节点
4.9.6.单链表的算法之遍历节点
4.9.7.单链表的算法之删除节点
4.9.8.单链表的算法之逆序
4.9.9.双链表的引入和基本实现
4.9.10.双链表的算法之插入节点
4.9.11.双链表的算法之遍历节点
4.9.12.双链表的算法之删除节点
4.9.13.linux内核链表
4.9.14.内核链表的基本算法和使用简介
4.9.15.什么是状态机
4.9.16.C语言实现简单的状态机
4.9.17.多线程简介

第二部分、章节介绍
4.9.1.链表的引入
本节从数组的缺陷说起引入链表的概念，目的是让大家自然认识到链表的意义和用途。
4.9.2.单链表的实现
本节介绍单链表的思路和编程实现，重点是链表节点的封装和实现。
4.9.3.单链表的算法之插入节点
本节讲述单链表操作的第一个算法，节点插入。主要介绍了头部插入和尾部插入这两种不同算法。
4.9.4.单链表的算法之插入节点续
本节为链表尾部插入的编程实践，带大家写代码实现从尾部插入节点。
4.9.5.从链表头部插入新节点
本节为链表头部插入的编程实践，带大家写代码实现从头部插入节点。
4.9.6.单链表的算法之遍历节点
本节是单链表的第二个算法：遍历链表的原理与编程实现。
4.9.7.单链表的算法之删除节点
本节实现单链表的第3个算法：删除指定节点。
4.9.8.单链表的算法之逆序
本节介绍单链表的最后一个算法：链表逆序，这也是我们处理的难度最大的一个算法了。
4.9.9.双链表的引入和基本实现
本节分析单链表的缺陷并同时引入双链表，并且编程实现双链表的节点。
4.9.10.双链表的算法之插入节点
本节讲解双链表的第一个算法：插入节点。同样分为头部插入和尾部插入两种。
4.9.11.双链表的算法之遍历节点
本节讲解双链表的第二个算法：遍历节点。
4.9.12.双链表的算法之删除节点
本节介绍双链表的删除节点的算法，并进行编程实践。
4.9.13.linux内核链表
本节通过分析我们讲的链表的一些缺陷来引入内核链表，介绍了内核链表的设计思路和主要特点。
4.9.14.内核链表的基本算法和使用简介
本节介绍内核链表的基本算法实现和内核链表的使用方法，在内核代码尤其是各种驱动中广安的使用了内核链表。
4.9.15.什么是状态机
本节从理论介绍了状态机的定义和分类，然后分析了状态机的主要用途，状态机的应用方向和解决的问题，目的是使大家理解为什么要有状态机。
4.9.16.C语言实现简单的状态机
本节课使用C语言实现了一个简单的状态机，目的是结合上节的理论让大家进一步理解状态机的实现、理解状态机实现了什么、解决了什么问题。
4.9.17.多线程简介
本节课简单介绍了多线程的概念，多线程编程，为后面应用编程部分使用多线程开了个头。

第三部分、随堂记录
4.9.1.链表的引入
4.9.1.1、从数组的缺陷说起
(1)数组有2个缺陷，一个是数组中所有元素的类型必须一致；第二个是数组的元素个数必须事先制定并且一旦指定之后不能更改。
(2)如何解决数组的2个缺陷：数组的第一个缺陷靠结构体去解决。结构体允许其中的元素的类型不相同，因此解决了数组的第一个缺陷。所以说结构体是因为数组不能解决某些问题所以才发明的。
(3)如何解决数组的第二个缺陷？我们希望数组的大小能够实时扩展。譬如我刚开始定了一个元素个数是10，后来程序运行时觉得不够因此动态扩展为20.普通的数组显然不行，我们可以对数组进行封装以达到这种目的；我们还可以使用一个新的数据结构来解决，这个新的数据结构就是链表。
总结：几乎可以这样理解：链表就是一个元素个数可以实时变大/变小的数组。

4.9.1.2、大学为什么都有新校区？
(1)学校初建的时候（类似于变量定义并初始化时），这时候因为旁边都是荒地而没有建筑，因此学校的校园大小由自己定的；但是学校建立了之后旁边慢慢的也有了其他建筑（类似于这个变量分配了之后，内存的相邻区域又分配了其他变量与这个变量地址相连），这时候你的校园随着发展感觉不够用了想要扩展，却发现邻居已经住满了，校园的四周全部都是别人的建筑，这时候学校要扩展有2个办法：第一个是拆迁，第二个是搬迁，第三个是外部扩展。
(2)拆迁基本行不通，因为成本太高了。
(3)搬迁可以行的通。程序中解决数组大小扩展的一个思路就是整体搬迁。具体步骤是：先在另外的空白内存处建立一个大的数组，然后把原来的数组中的元素的值整个复制到新数组的头部，然后再释放掉原来数组的内存空间，并且把新的数组去替代原来的数组。这种可变数组在C语言中不支持，但是在更高级语言如C++、Java等里面是支持的。
(4)外部扩展的思路是最常见的，基本可以说是最合理的。它的一个思路就是化整为零，在原来的不动的前提下去外部扩展新的分基地。外部扩展在学校的例子中就是新校区；外部扩展在编程解决数组问题的点上就是链表。

4.9.1.3、链表是什么样的？
(1)顾名思义，链表就是用锁链连接起来的表。这里的表指的是一个一个的节点（一个节点就是一个校区），节点中有一些内存可以用来存储数据（所以叫表，表就是数据表）；这里的锁链指的是链接各个表的方法，C语言中用来连接2个表（其实就是2块内存）的方法就是指针。
(2)链表是由若干个节点组成的（链表的各个节点结构是完全类似的），节点是由有效数据和指针组成的。有效数据区域用来存储信息完成任务的，指针区域用于指向链表的下一个节点从而构成链表。

4.9.1.4、时刻别忘了链表是用来干嘛的
(1)时刻谨记：链表就是用来解决数组的大小不能动态扩展的问题，所以链表其实就是当数组用的。直白点：链表能完成的任务用数组也能完成，数组能完成的任务用链表也能完成。但是灵活性不一样。
(2)简单说：链表就是用来存储数据的。链表用来存数据相对于数组来说优点就是灵活性，需要多少个动态分配多少个，不占用额外的内存。数组的优势是使用简单（简单粗暴）。

4.9.2.单链表的实现
4.9.2.1、单链表的节点构成
(1)链表是由节点组成的，节点中包含：有效数据和指针。
(2)定义的struct node只是一个结构体，本身并没有变量生成，也不占用内存。结构体定义相当于为链表节点定义了一个模板，但是还没有一个节点，将来在实际创建链表时需要一个节点时用这个模板来复制一个即可。

4.9.2.2、堆内存的申请和使用
(1)链表的内存要求比较灵活，不能用栈，也不能用data数据段。只能用堆内存。
(2)使用堆内存来创建一个链表节点的步骤：1、申请堆内存，大小为一个节点的大小（检查申请结果是否正确）；2、清理申请到的堆内存；3、把申请到的堆内存当作一个新节点；4、填充你哦个新节点的有效数据和指针区域。

4.9.2.3、链表的头指针
(1)头指针并不是节点，而是一个普通指针，只占4字节。头指针的类型是struct node *类型的，所以它才能指向链表的节点。
(2)一个典型的链表的实现就是：头指针指向链表的第1个节点，然后第1个节点中的指针指向下一个节点，然后依次类推一直到最后一个节点。这样就构成了一个链。

4.9.2.4、实战：构建一个简单的单链表
(1)目标：构建一个链表，然后将一些数据（譬如1，2，3三个数字）存储在链表中

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>


// 构建一个链表的节点
struct node
{
	int data;				// 有效数据
	struct node *pNext;		// 指向下一个节点的指针
};


int main(void)
{
	// 定义头指针
	struct node *pHeader = NULL;
	
	/********************************************************************/
	// 每创建一个新的节点，把这个新的节点和它前一个节点关联起来
	// 创建一个链表节点
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return -1;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = 1;
	p->pNext = NULL;			// 将来要指向下一个节点的首地址
								// 实际操作时将下一个节点malloc返回的指针赋值给这个
								
	pHeader = p;	// 将本节点和它前面的头指针关联起来					
	/********************************************************************/
	
	
	/********************************************************************/
	// 每创建一个新的节点，把这个新的节点和它前一个节点关联起来
	// 创建一个链表节点
	struct node *p1 = (struct node *)malloc(sizeof(struct node));
	if (NULL == p1)
	{
		printf("malloc error.\n");
		return -1;
	}
	// 清理申请到的堆内存
	bzero(p1, sizeof(struct node));
	// 填充节点
	p1->data = 2;
	p1->pNext = NULL;			// 将来要指向下一个节点的首地址
								// 实际操作时将下一个节点malloc返回的指针赋值给这个
								
	p->pNext = p1;	// 将本节点和它前面的头指针关联起来					
	/********************************************************************/
	
	
	/********************************************************************/
	// 每创建一个新的节点，把这个新的节点和它前一个节点关联起来
	// 创建一个链表节点
	struct node *p2 = (struct node *)malloc(sizeof(struct node));
	if (NULL == p2)
	{
		printf("malloc error.\n");
		return -1;
	}
	// 清理申请到的堆内存
	bzero(p2, sizeof(struct node));
	// 填充节点
	p2->data = 3;
	p1->pNext = p2;			// 将来要指向下一个节点的首地址
								// 实际操作时将下一个节点malloc返回的指针赋值给这个				
	/********************************************************************/
	
	// 至此创建了一个有1个头指针+3个完整节点的链表。
	
	// 下面是4.9.3节的代码
	// 访问链表中的各个节点的有效数据，这个访问必须注意不能使用p、p1、p2，而只能
	// 使用pHeader。
	
	// 访问链表第1个节点的有效数据
	printf("node1 data: %d.\n", pHeader->data);	
	printf("p->data: %d.\n", p->data);			// pHeader->data等同于p->data
	
	// 访问链表第2个节点的有效数据
	printf("node2 data: %d.\n", pHeader->pNext->data);	
	printf("p1->data: %d.\n", p1->data);	
	// pHeader->pNext->data等同于p1->data
	
	// 访问链表第3个节点的有效数据
	printf("node3 data: %d.\n", pHeader->pNext->pNext->data);	
	printf("p2->data: %d.\n", p2->data);			
	// pHeader->pNext->pNext->data等同于p2->data
	
	
	return 0;
}

4.9.3.单链表的算法之插入节点
4.9.3.1、继续上节，访问链表中各个节点的数据
(1)只能用头指针，不能用各个节点自己的指针。因为在实际当中我们保存链表的时候是不会保存各个节点的指针的，只能通过头指针来访问链表节点。
(2)前一个节点内部的pNext指针能帮助我们找到下一个节点。
4.9.3.2、将创建节点的代码封装成一个函数
(1)封装时的关键点就是函数的接口（函数参数和返回值）的设计
4.9.3.3、从链表头部插入新节点
4.9.3.4、从链表尾部插入新节点
(1)尾部插入简单点，因为前面已经建立好的链表不用动。直接动最后一个就可以了。

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>


// 构建一个链表的节点
struct node
{
	int data;				// 有效数据
	struct node *pNext;		// 指向下一个节点的指针
};

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

// 思路：由头指针向后遍历，直到走到原来的最后一个节点。原来最后一个节点里面的pNext是NULL，现在我们只要将它改成new就可以了。添加了之后新节点就变成了最后一个。
void insert_tail(struct node *pH, struct node *new)
{
	// 分两步来完成插入
	// 第一步，先找到链表中最后一个节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往后走一个节点
	}
	
	// 第二步，将新节点插入到最后一个节点尾部
	p->pNext = new;
}

int main(void)
{
	// 定义头指针
	//struct node *pHeader = NULL;			// 这样直接insert_tail会段错误。
	struct node *pHeader = create_node(1);
	
	insert_tail(pHeader, create_node(2));
	insert_tail(pHeader, create_node(3));
	insert_tail(pHeader, create_node(4));
/*
	pHeader = create_node(1);	
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext = create_node(432);		
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext->pNext = create_node(123);				
	// 将来要指向下一个节点的首地址

	// 至此创建了一个有1个头指针+3个完整节点的链表。
*/

	
	// 下面是4.9.3节的代码
	// 访问链表中的各个节点的有效数据，这个访问必须注意不能使用p、p1、p2，而只能
	// 使用pHeader。
	
	// 访问链表第1个节点的有效数据
	printf("node1 data: %d.\n", pHeader->data);	
	//printf("p->data: %d.\n", p->data);			// pHeader->data等同于p->data
	
	// 访问链表第2个节点的有效数据
	printf("node2 data: %d.\n", pHeader->pNext->data);	
	//printf("p1->data: %d.\n", p1->data);	
	// pHeader->pNext->data等同于p1->data
	
	// 访问链表第3个节点的有效数据
	printf("node3 data: %d.\n", pHeader->pNext->pNext->data);	
	//printf("p2->data: %d.\n", p2->data);			
	// pHeader->pNext->pNext->data等同于p2->data
	
	
	return 0;
}

4.9.4.单链表的算法之插入节点续
4.9.4.1、详解链表头部插入函数
4.9.4.2、什么是头节点
(1)问题：因为我们在insert_tail中直接默认了头指针指向的有一个节点，因此如果程序中直接定义了头指针后就直接insert_tail就会报段错误。我们不得不在定义头指针之后先create_node创建一个新节点给头指针初始化，否则不能避免这个错误；但是这样解决让程序看起来逻辑有点不太顺，因为看起来第一个节点和后面的节点的创建、添加方式有点不同。
(2)链表还有另外一种用法，就是把头指针指向的第一个节点作为头节点使用。头节点的特点是：第一，它紧跟在头指针后面。第二，头节点的数据部分是空的（有时候不是空的，而是存储整个链表的节点数），指针部分指向下一个节点，也就是第一个节点。
(3)这样看来，头节点确实和其他节点不同。我们在创建一个链表时添加节点的方法也不同。头节点在创建头指针时一并创建并且和头指针关联起来；后面的真正的存储数据的节点用节点添加的函数来完成，譬如insert_tail.
(4)链表有没有头节点是不同的。体现在链表的插入节点、删除节点、遍历节点、解析链表的各个算法函数都不同。所以如果一个链表设计的时候就有头节点那么后面的所有算法都应该这样来处理；如果设计时就没有头节点，那么后面的所有算法都应该按照没有头节点来做。实际编程中两种链表都有人用，所以大家在看别人写的代码时一定要注意看它有没有头节点。

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>


// 构建一个链表的节点
struct node
{
	int data;				// 有效数据
	struct node *pNext;		// 指向下一个节点的指针
};

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

// 思路：由头指针向后遍历，直到走到原来的最后一个节点。原来最后一个节点里面的pNext是NULL，现在我们只要将它改成new就可以了。添加了之后新节点就变成了最后一个。
// 计算添加了新的节点后总共有多少个节点，然后把这个数写进头节点中。
void insert_tail(struct node *pH, struct node *new)
{
	int cnt = 0;
	// 分两步来完成插入
	// 第一步，先找到链表中最后一个节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往后走一个节点
		cnt++;
	}
	
	// 第二步，将新节点插入到最后一个节点尾部
	p->pNext = new;
	pH->data = cnt + 1;
}

int main(void)
{
	// 定义头指针
	//struct node *pHeader = NULL;			// 这样直接insert_tail会段错误。
	struct node *pHeader = create_node(0);
	
	insert_tail(pHeader, create_node(1));
	insert_tail(pHeader, create_node(2));
	insert_tail(pHeader, create_node(3));
/*
	pHeader = create_node(1);	
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext = create_node(432);		
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext->pNext = create_node(123);				
	// 将来要指向下一个节点的首地址

	// 至此创建了一个有1个头指针+3个完整节点的链表。
*/

	
	// 下面是4.9.3节的代码
	// 访问链表中的各个节点的有效数据，这个访问必须注意不能使用p、p1、p2，而只能
	// 使用pHeader。
	
	// 访问链表头节点的有效数据
	printf("beader node data: %d.\n", pHeader->data);	

	// 访问链表第1个节点的有效数据
	printf("node1 data: %d.\n", pHeader->pNext->data);	
	
	// 访问链表第2个节点的有效数据
	printf("node2 data: %d.\n", pHeader->pNext->pNext->data);	
	
	// 访问链表第3个节点的有效数据
	printf("node3 data: %d.\n", pHeader->pNext->pNext->pNext->data);	
	
	return 0;
}

4.9.5.从链表头部插入新节点
(1)注意写代码过程中的箭头符号，和说话过程中的指针指向。这是两码事，容易搞混。箭头符号实际上是用指针方式来访问结构体，所以箭头符号的实质是访问结构体中的成员。更清楚一点说程序中的箭头和链表的连接没有任何关系；链表中的节点通过指针指向来连接，编程中表现为一个赋值语句（用=来进行连接），实质是把后一个节点的首地址，赋值给前一个节点中的pNext元素做为值。
(2)链表可以从头部插入，也可以从尾部插入。也可以两头插入。头部插入和尾部插入对链表来说几乎没有差别。对链表本身无差别，但是有时候对业务逻辑有差别。

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>


// 构建一个链表的节点
struct node
{
	int data;				// 有效数据
	struct node *pNext;		// 指向下一个节点的指针
};

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

// 思路：由头指针向后遍历，直到走到原来的最后一个节点。原来最后一个节点里面的pNext是NULL，现在我们只要将它改成new就可以了。添加了之后新节点就变成了最后一个。
// 计算添加了新的节点后总共有多少个节点，然后把这个数写进头节点中。
void insert_tail(struct node *pH, struct node *new)
{
	int cnt = 0;
	// 分两步来完成插入
	// 第一步，先找到链表中最后一个节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往后走一个节点
		cnt++;
	}
	
	// 第二步，将新节点插入到最后一个节点尾部
	p->pNext = new;
	pH->data = cnt + 1;
}

// 思路：
void insert_head(struct node *pH, struct node *new)
{
	// 第1步： 新节点的next指向原来的第一个节点
	new->pNext = pH->pNext;
	
	// 第2步： 头节点的next指向新节点的地址
	pH->pNext = new;
	
	// 第3步： 头节点中的计数要加1
	pH->data += 1;
}


int main(void)
{
	// 定义头指针
	//struct node *pHeader = NULL;			// 这样直接insert_tail会段错误。
	struct node *pHeader = create_node(0);
	
	insert_head(pHeader, create_node(1));
	insert_tail(pHeader, create_node(2));
	insert_head(pHeader, create_node(3));
/*
	pHeader = create_node(1);	
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext = create_node(432);		
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext->pNext = create_node(123);				
	// 将来要指向下一个节点的首地址

	// 至此创建了一个有1个头指针+3个完整节点的链表。
*/

	
	// 下面是4.9.3节的代码
	// 访问链表中的各个节点的有效数据，这个访问必须注意不能使用p、p1、p2，而只能
	// 使用pHeader。
	
	// 访问链表头节点的有效数据
	printf("beader node data: %d.\n", pHeader->data);	

	// 访问链表第1个节点的有效数据
	printf("node1 data: %d.\n", pHeader->pNext->data);	
	
	// 访问链表第2个节点的有效数据
	printf("node2 data: %d.\n", pHeader->pNext->pNext->data);	
	
	// 访问链表第3个节点的有效数据
	printf("node3 data: %d.\n", pHeader->pNext->pNext->pNext->data);	
	
	return 0;
}

4.9.6.单链表的算法之遍历节点
4.9.6.1、什么是遍历
(1)遍历就是把单链表中的各个节点挨个拿出来，就叫遍历。
(2)遍历的要点：一是不能遗漏、二是不能重复、追求效率。
4.9.6.2、如何遍历单链表
(1)分析一个数据结构如何遍历，关键是分析这个数据结构本身的特点。然后根据本身特点来制定它的遍历算法。
(2)单链表的特点就是由很多个节点组成，头指针+头节点为整个链表的起始，最后一个节点的特征是它内部的pNext指针值为NULL。从起始到结尾中间由各个节点内部的pNext指针来挂接。由起始到结尾的路径有且只有一条。单链表的这些特点就决定了它的遍历算法。
(3)遍历方法：从头指针+头节点开始，顺着链表挂接指针依次访问链表的各个节点，取出这个节点的数据，然后再往下一个节点，直到最后一个节点，结束返回。

4.9.6.3、编程实战
(1)写一个链表遍历的函数，void bianli(struct node*pH);

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>


// 构建一个链表的节点
struct node
{
	int data;				// 有效数据
	struct node *pNext;		// 指向下一个节点的指针
};

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

// 思路：由头指针向后遍历，直到走到原来的最后一个节点。原来最后一个节点里面的pNext是NULL，现在我们只要将它改成new就可以了。添加了之后新节点就变成了最后一个。
// 计算添加了新的节点后总共有多少个节点，然后把这个数写进头节点中。
void insert_tail(struct node *pH, struct node *new)
{
	int cnt = 0;
	// 分两步来完成插入
	// 第一步，先找到链表中最后一个节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往后走一个节点
		cnt++;
	}
	
	// 第二步，将新节点插入到最后一个节点尾部
	p->pNext = new;
	pH->data = cnt + 1;
}

// 思路：
void insert_head(struct node *pH, struct node *new)
{
	// 第1步： 新节点的next指向原来的第一个节点
	new->pNext = pH->pNext;
	
	// 第2步： 头节点的next指向新节点的地址
	pH->pNext = new;
	
	// 第3步： 头节点中的计数要加1
	pH->data += 1;
}

// 遍历单链表，pH为指向单链表的头指针，遍历的节点数据打印出来
void bianli(struct node*pH)
{
	//pH->data				// 头节点数据，不是链表的常规数据，不要算进去了
	//struct node *p = pH;		// 错误，因为头指针后面是头节点
	struct node *p = pH->pNext;	// p直接走到第一个节点
	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		printf("node data: %d.\n", p->data);
		p = p->pNext;				// 走到下一个节点，也就是循环增量
	}
	printf("node data: %d.\n", p->data);
	printf("-------------完了-------------\n");
}

// 1、思考下为什么这样能解决问题；2、思考下设计链表时为什么要设计头节点
void bianli2(struct node*pH)
{
	//pH->data				// 头节点数据，不是链表的常规数据，不要算进去了
	struct node *p = pH;		// 头指针后面是头节点

	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		p = p->pNext;				// 走到下一个节点，也就是循环增量
		printf("node data: %d.\n", p->data);
	}

	printf("-------------完了-------------\n");
}



int main(void)
{
	// 定义头指针
	//struct node *pHeader = NULL;			// 这样直接insert_tail会段错误。
	struct node *pHeader = create_node(0);
	
	insert_head(pHeader, create_node(11));
	insert_head(pHeader, create_node(12));
	insert_head(pHeader, create_node(13));
/*
	pHeader = create_node(1);	
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext = create_node(432);		
	// 将本节点和它前面的头指针关联起来					

	pHeader->pNext->pNext = create_node(123);				
	// 将来要指向下一个节点的首地址

	// 至此创建了一个有1个头指针+3个完整节点的链表。
*/

	
	// 下面是4.9.3节的代码
	// 访问链表中的各个节点的有效数据，这个访问必须注意不能使用p、p1、p2，而只能
	// 使用pHeader。
	
	// 访问链表头节点的有效数据
	printf("beader node data: %d.\n", pHeader->data);	

	bianli2(pHeader);
	
	
/*
	// 访问链表第1个节点的有效数据
	printf("node1 data: %d.\n", pHeader->pNext->data);	
	
	// 访问链表第2个节点的有效数据
	printf("node2 data: %d.\n", pHeader->pNext->pNext->data);	
	
	// 访问链表第3个节点的有效数据
	printf("node3 data: %d.\n", pHeader->pNext->pNext->pNext->data);	
*/	
	return 0;
}

4.9.7.单链表的算法之删除节点
4.9.7.1、为什么要删除节点
(1)一直在强调，链表到底用来干嘛的？
(2)有时候链表节点中的数据不想要了，因此要删掉这个节点。
4.9.7.2、删除节点的2个步骤
(1)第一步：找到要删除的节点；第二步：删除这个节点。
4.9.7.3、如何找到待删除的节点
(1)通过遍历来查找节点。从头指针+头节点开始，顺着链表依次将各个节点拿出来，按照一定的方法比对，找到我们要删除的那个节点。
4.9.7.4、如何删除一个节点
(1)待删除的节点不是尾节点的情况:首先把待删除的节点的前一个节点的pNext指针指向待删除的节点的后一个节点的首地址（这样就把这个节点从链表中摘出来了），然后再将这个摘出来的节点free掉接口。
(2)待删除的节点是尾节点的情况：首先把待删除的尾节点的前一个节点的pNext指针指向null（这时候就相当于原来尾节点前面的一个节点变成了新的尾节点），然后将摘出来的节点free掉。

4.9.7.5、注意堆内存的释放
(1)前面几节课我们写的代码最终都没有释放堆内存。当程序都结束了的情况下那些没有free的堆内存也被释放了。
(2)有时候我们的程序运行时间很久，这时候malloc的内存如果没有free会一直被占用直到你free释放它或者整个程序终止。

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>


// 构建一个链表的节点
struct node
{
	int data;				// 有效数据
	struct node *pNext;		// 指向下一个节点的指针
};

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

// 思路：由头指针向后遍历，直到走到原来的最后一个节点。原来最后一个节点里面的pNext是NULL，现在我们只要将它改成new就可以了。添加了之后新节点就变成了最后一个。
// 计算添加了新的节点后总共有多少个节点，然后把这个数写进头节点中。
void insert_tail(struct node *pH, struct node *new)
{
	int cnt = 0;
	// 分两步来完成插入
	// 第一步，先找到链表中最后一个节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往后走一个节点
		cnt++;
	}
	
	// 第二步，将新节点插入到最后一个节点尾部
	p->pNext = new;
	pH->data = cnt + 1;
}

// 思路：
void insert_head(struct node *pH, struct node *new)
{
	// 第1步： 新节点的next指向原来的第一个节点
	new->pNext = pH->pNext;
	
	// 第2步： 头节点的next指向新节点的地址
	pH->pNext = new;
	
	// 第3步： 头节点中的计数要加1
	pH->data += 1;
}

// 遍历单链表，pH为指向单链表的头指针，遍历的节点数据打印出来
void bianli(struct node*pH)
{
	//pH->data				// 头节点数据，不是链表的常规数据，不要算进去了
	//struct node *p = pH;		// 错误，因为头指针后面是头节点
	struct node *p = pH->pNext;	// p直接走到第一个节点
	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		printf("node data: %d.\n", p->data);
		p = p->pNext;				// 走到下一个节点，也就是循环增量
	}
	printf("node data: %d.\n", p->data);
	printf("-------------完了-------------\n");
}

// 1、思考下为什么这样能解决问题；2、思考下设计链表时为什么要设计头节点
void bianli2(struct node*pH)
{
	//pH->data				// 头节点数据，不是链表的常规数据，不要算进去了
	struct node *p = pH;		// 头指针后面是头节点

	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		p = p->pNext;				// 走到下一个节点，也就是循环增量
		printf("node data: %d.\n", p->data);
	}

	printf("-------------完了-------------\n");
}

// 从链表pH中删除节点，待删除的节点的特征是数据区等于data
// 返回值：当找到并且成功删除了节点则返回0，当未找到节点时返回-1
int delete_node(struct node*pH, int data)
{
	// 找到这个待删除的节点，通过遍历链表来查找
	struct node *p = pH;			// 用来指向当前节点
	struct node *pPrev = NULL;		// 用来指向当前节点的前一个节点

	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		pPrev = p;					// 在p走向下一个节点前先将其保存
		p = p->pNext;				// 走到下一个节点，也就是循环增量
		// 判断这个节点是不是我们要找的那个节点
		if (p->data == data)
		{
			// 找到了节点，处理这个节点
			// 分为2种情况，一个是找到的是普通节点，另一个是找到的是尾节点
			// 删除节点的困难点在于：通过链表的遍历依次访问各个节点，找到这个节点
			// 后p指向了这个节点，但是要删除这个节点关键要操作前一个节点，但是这
			// 时候已经没有指针指向前一个节点了，所以没法操作。解决方案就是增加
			// 一个指针指向当前节点的前一个节点
			if (NULL == p->pNext)
			{
				// 尾节点
				pPrev->pNext = NULL;		// 原来尾节点的前一个节点变成新尾节点
				free(p);					// 释放原来的尾节点的内存
			}
			else
			{
				// 普通节点
				pPrev->pNext = p->pNext;	// 要删除的节点的前一个节点和它的后一个节点相连，这样就把要删除的节点给摘出来了
				free(p);
			}
			// 处理完成之后退出程序
			return 0;
		}
	}
	// 到这里还没找到，说明链表中没有我们想要的节点
	printf("没找到这个节点.\n");
	return -1;
}



int main(void)
{
	// 定义头指针
	//struct node *pHeader = NULL;			// 这样直接insert_tail会段错误。
	struct node *pHeader = create_node(0);
	
	insert_head(pHeader, create_node(11));
	insert_head(pHeader, create_node(12));
	insert_head(pHeader, create_node(13));
	insert_head(pHeader, create_node(12));

	bianli2(pHeader);
	
	delete_node(pHeader, 12);
	printf("------------------删除后-------------\n");
	bianli2(pHeader);
	
	return 0;
}

4.9.8.单链表的算法之逆序
4.9.8.1、什么是链表的逆序
(1)链表的逆序又叫反向，意思就是把链表中所有的有效节点在链表中的顺序给反过来。

4.9.8.2、单链表逆序算法分析
(1)当我们对一个数据结构进行一个操作时，我们就需要一套算法。这就是数据结构和算法的关系。
(2)我总结：算法有2个层次。第一个层次是数学和逻辑上的算法；第二次个层次是用编程语言来实现算法。
(3)从逻辑上来讲，链表的逆序有很多种方法。这些方法都能实现最终的需要，但是效率是不一样的。彼此的可扩展性、容错性等不同。
(4)思路：首先遍历原链表，然后将原链表中的头指针和头节点作为新链表的头指针和头节点，原链表中的有效节点挨个依次取出来，采用头插入的方法插入新链表中即可。
(5)链表逆序 = 遍历 + 头插入

4.9.8.3、编程实战

#include <stdio.h>
#include <strings.h>
#include <stdlib.h>


// 构建一个链表的节点
struct node
{
	int data;				// 有效数据
	struct node *pNext;		// 指向下一个节点的指针
};

// 作用：创建一个链表节点
// 返回值：指针，指针指向我们本函数新创建的一个节点的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申请到的堆内存
	bzero(p, sizeof(struct node));
	// 填充节点
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

// 思路：由头指针向后遍历，直到走到原来的最后一个节点。原来最后一个节点里面的pNext是NULL，现在我们只要将它改成new就可以了。添加了之后新节点就变成了最后一个。
// 计算添加了新的节点后总共有多少个节点，然后把这个数写进头节点中。
void insert_tail(struct node *pH, struct node *new)
{
	int cnt = 0;
	// 分两步来完成插入
	// 第一步，先找到链表中最后一个节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往后走一个节点
		cnt++;
	}
	
	// 第二步，将新节点插入到最后一个节点尾部
	p->pNext = new;
	pH->data = cnt + 1;
}

// 思路：
void insert_head(struct node *pH, struct node *new)
{
	// 第1步： 新节点的next指向原来的第一个节点
	new->pNext = pH->pNext;
	
	// 第2步： 头节点的next指向新节点的地址
	pH->pNext = new;
	
	// 第3步： 头节点中的计数要加1
	pH->data += 1;
}

// 遍历单链表，pH为指向单链表的头指针，遍历的节点数据打印出来
void bianli(struct node*pH)
{
	//pH->data				// 头节点数据，不是链表的常规数据，不要算进去了
	//struct node *p = pH;		// 错误，因为头指针后面是头节点
	struct node *p = pH->pNext;	// p直接走到第一个节点
	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		printf("node data: %d.\n", p->data);
		p = p->pNext;				// 走到下一个节点，也就是循环增量
	}
	printf("node data: %d.\n", p->data);
	printf("-------------完了-------------\n");
}

// 1、思考下为什么这样能解决问题；2、思考下设计链表时为什么要设计头节点
void bianli2(struct node*pH)
{
	//pH->data				// 头节点数据，不是链表的常规数据，不要算进去了
	struct node *p = pH;		// 头指针后面是头节点

	printf("-----------开始遍历-----------\n");
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		p = p->pNext;				// 走到下一个节点，也就是循环增量
		printf("node data: %d.\n", p->data);
	}

	printf("-------------完了-------------\n");
}

// 从链表pH中删除节点，待删除的节点的特征是数据区等于data
// 返回值：当找到并且成功删除了节点则返回0，当未找到节点时返回-1
int delete_node(struct node*pH, int data)
{
	// 找到这个待删除的节点，通过遍历链表来查找
	struct node *p = pH;			// 用来指向当前节点
	struct node *pPrev = NULL;		// 用来指向当前节点的前一个节点

	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		pPrev = p;					// 在p走向下一个节点前先将其保存
		p = p->pNext;				// 走到下一个节点，也就是循环增量
		// 判断这个节点是不是我们要找的那个节点
		if (p->data == data)
		{
			// 找到了节点，处理这个节点
			// 分为2种情况，一个是找到的是普通节点，另一个是找到的是尾节点
			// 删除节点的困难点在于：通过链表的遍历依次访问各个节点，找到这个节点
			// 后p指向了这个节点，但是要删除这个节点关键要操作前一个节点，但是这
			// 时候已经没有指针指向前一个节点了，所以没法操作。解决方案就是增加
			// 一个指针指向当前节点的前一个节点
			if (NULL == p->pNext)
			{
				// 尾节点
				pPrev->pNext = NULL;		// 原来尾节点的前一个节点变成新尾节点
				free(p);					// 释放原来的尾节点的内存
			}
			else
			{
				// 普通节点
				pPrev->pNext = p->pNext;	// 要删除的节点的前一个节点和它的后一个节点相连，这样就把要删除的节点给摘出来了
				free(p);
			}
			// 处理完成之后退出程序
			return 0;
		}
	}
	// 到这里还没找到，说明链表中没有我们想要的节点
	printf("没找到这个节点.\n");
	return -1;
}

// 将pH指向的链表逆序
void reverse_linkedlist(struct node *pH)
{
	struct node *p = pH->pNext;		// pH指向头节点，p指向第1个有效节点
	struct node *pBack;				// 保存当前节点的后一个节点地址
	
	// 当链表没有有效节点或者只有一个有效节点时，逆序不用做任何操作
	if ((NULL ==p) || (NULL == p->pNext))
		return;
	
	// 当链表有2个及2个以上节点时才需要真正进行逆序操作
	while (NULL != p->pNext)		// 是不是最后一个节点
	{
		// 原链表中第一个有效节点将是逆序后新链表的尾节点，尾节点的pNext指向NULL
		pBack = p->pNext;			// 保存p节点后面一个节点地址
		if (p == pH->pNext)
		{
			// 原链表第一个有效节点
			p->pNext = NULL;
		}
		else
		{
			// 原链表的非第1个有效节点
			p->pNext = pH->pNext;
		}
		pH->pNext = p;
		
		//p = p->pNext;		// 这样已经不行了，因为p->pNext已经被改过了
		p = pBack;			// 走到下一个节点
	}
	// 循环结束后，最后一个节点仍然缺失
	insert_head(pH, p);
}


int main(void)
{
	// 定义头指针
	//struct node *pHeader = NULL;			// 这样直接insert_tail会段错误。
	struct node *pHeader = create_node(0);
	
	insert_tail(pHeader, create_node(11));
	insert_tail(pHeader, create_node(12));
	insert_tail(pHeader, create_node(13));
	insert_tail(pHeader, create_node(14));

	bianli2(pHeader);
	
	reverse_linkedlist(pHeader);
	printf("------------------逆序后-------------\n");
	bianli2(pHeader);
	
	return 0;
}

4.9.9.双链表的引入和基本实现
4.9.9.1、单链表的局限性
(1)单链表是对数组的一个扩展，解决了数组的大小比较死板不容易扩展的问题。使用堆内存来存储数据，将数据分散到各个节点之间，其各个节点在内存中可以不相连，节点之间通过指针进行单向链接。链表中的各个节点内存不相连，有利于利用碎片化的内存。
(2)单链表各个节点之间只由一个指针单向链接，这样实现有一些局限性。局限性主要体现在单链表只能经由指针单向移动（一旦指针移动过某个节点就无法再回来，如果要再次操作这个节点除非从头指针开始再次遍历一次），因此单链表的某些操作就比较麻烦（算法比较有局限）。回忆之前单链表的所有操作（插入、删除节点、 遍历、从单链表中取某个节点的数·····），因为单链表的单向移动性导致了不少麻烦。
总结：单链表的单向移动性导致我们在操作单链表时，当前节点只能向后移动不能向前移动，因此不自由，不利于解决更复杂的算法。

4.9.9.2、解决思路：有效数据+2个指针的节点（双链表）
(1)单链表的节点 = 有效数据 + 指针（指针指向后一个节点）
(2)双向链表的节点 = 有效数据 + 2个指针（一个指向后一个节点，另一个指向前一个节点）

4.9.9.3、双链表的封装和编程实现

#include <stdio.h>
#include <stdlib.h>

// 双链表的节点
struct node 
{
	int data;					// 有效数据
	struct node *pPrev;			// 前向指针，指向前一个节点
	struct node *pNext;			// 后向指针，指向后一个节点
};

struct node *create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	p->data = data;
	p->pPrev = NULL;
	p->pNext = NULL;		// 默认创建的节点前向后向指针都指向NULL
	
	return p;
}


int main(void)
{
	struct node *pHeader = create_node(0);		// 头指针
	
	
	
	
	return 0;
}

4.9.10.双链表的算法之插入节点
4.9.10.1、尾部插入
4.9.10.2、头部插入

#include <stdio.h>
#include <stdlib.h>


// 双链表的节点
struct node 
{
	int data;					// 有效数据
	struct node *pPrev;			// 前向指针，指向前一个节点
	struct node *pNext;			// 后向指针，指向后一个节点
};

struct node *create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	p->data = data;
	p->pPrev = NULL;
	p->pNext = NULL;		// 默认创建的节点前向后向指针都指向NULL
	
	return p;
}

// 将新节点new插入到链表pH的尾部
void insert_tail(struct node *pH, struct node *new)
{
	// 第一步先走到链表的尾节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;			// 第一次循环走过了头节点
	}
	// 循环结束后p就指向了原来的最后一个节点
	// 第二步：将新节点插入到原来的尾节点的后面
	p->pNext = new;				// 后向指针关联好了。新节点的地址和前节点的next
	new->pPrev = p;				// 前向指针关联好了。新节点的prev和前节点的地址
								// 前节点的prev和新节点的next指针未变动
}

// 将新节点new前插入链表pH中。
// 算法参照图示进行连接，一共有4个指针需要赋值。注意的是顺序。
void insert_head(struct node *pH, struct node *new)
{
	// 新节点的next指针指向原来的第1个有效节点的地址
	new->pNext = pH->pNext;
	
	// 原来第1个有效节点的prev指针指向新节点的地址
	if (NULL != pH->pNext)
		pH->pNext->pPrev = new;
	
	// 头节点的next指针指向新节点地址
	pH->pNext = new;
	
	// 新节点的prev指针指向头节点的地址
	new->pPrev = pH;
}


int main(void)
{
	struct node *pHeader = create_node(0);		// 头指针
	
	insert_head(pHeader, create_node(11));
	insert_head(pHeader, create_node(12));
	insert_head(pHeader, create_node(13));
	
	// 遍历
	printf("node 1 data: %d.\n", pHeader->pNext->data);
	printf("node 2 data: %d.\n", pHeader->pNext->pNext->data);
	printf("node 3 data: %d.\n", pHeader->pNext->pNext->pNext->data);

	struct node *p = pHeader->pNext->pNext->pNext;		// p指向了最后一个节点
	printf("node 3 data: %d.\n", p->data);
	printf("node 2 data: %d.\n", p->pPrev->data);
	printf("node 1 data: %d.\n", p->pPrev->pPrev->data);
	
	
	
	return 0;
}

4.9.11.双链表的算法之遍历节点
(1)双链表是单链表的一个父集。双链表中如何完全无视pPrev指针，则双链表就变成了单链表。这就决定了双链表的正向遍历（后向遍历）和单链表是完全相同的。
(2)双链表中因为多了pPrev指针，因此双链表还可以前向遍历（从链表的尾节点向前面依次遍历直到头节点）。但是前向遍历的意义并不大，主要是因为很少有当前当了尾节点需要前向遍历的情况。
(3)总结：双链表是对单链表的一种有成本的扩展，但是这个扩展在有些时候意义不大，在另一些时候意义就比较大。因此在实践用途中要根据业务要求选择适合的链表。

#include <stdio.h>
#include <stdlib.h>


// 双链表的节点
struct node 
{
	int data;					// 有效数据
	struct node *pPrev;			// 前向指针，指向前一个节点
	struct node *pNext;			// 后向指针，指向后一个节点
};

struct node *create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	p->data = data;
	p->pPrev = NULL;
	p->pNext = NULL;		// 默认创建的节点前向后向指针都指向NULL
	
	return p;
}

// 将新节点new插入到链表pH的尾部
void insert_tail(struct node *pH, struct node *new)
{
	// 第一步先走到链表的尾节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;			// 第一次循环走过了头节点
	}
	// 循环结束后p就指向了原来的最后一个节点
	// 第二步：将新节点插入到原来的尾节点的后面
	p->pNext = new;				// 后向指针关联好了。新节点的地址和前节点的next
	new->pPrev = p;				// 前向指针关联好了。新节点的prev和前节点的地址
								// 前节点的prev和新节点的next指针未变动
}

// 将新节点new前插入链表pH中。
// 算法参照图示进行连接，一共有4个指针需要赋值。注意的是顺序。
void insert_head(struct node *pH, struct node *new)
{
	// 新节点的next指针指向原来的第1个有效节点的地址
	new->pNext = pH->pNext;
	
	// 原来第1个有效节点的prev指针指向新节点的地址
	if (NULL != pH->pNext)
		pH->pNext->pPrev = new;
	
	// 头节点的next指针指向新节点地址
	pH->pNext = new;
	
	// 新节点的prev指针指向头节点的地址
	new->pPrev = pH;
}

// 后向遍历一个双链表
void bianli(struct node *pH)
{
	struct node *p = pH;
	
	while (NULL != p->pNext)
	{
		p = p->pNext;
		
		printf("data = %d.\n", p->data);
	}
}

// 前向遍历一个双遍历，参数pTail要指向链表末尾
void qianxiang_bianli(struct node *pTail)
{
	struct node *p = pTail;
	
	while (NULL != p->pPrev)
	{
		printf("data = %d.\n", p->data);
		
		p = p->pPrev;
	}
}

int main(void)
{
	struct node *pHeader = create_node(0);		// 头指针
	
	insert_head(pHeader, create_node(11));
	insert_head(pHeader, create_node(12));
	insert_head(pHeader, create_node(13));
	
	
	/*
	// 遍历
	printf("node 1 data: %d.\n", pHeader->pNext->data);
	printf("node 2 data: %d.\n", pHeader->pNext->pNext->data);
	printf("node 3 data: %d.\n", pHeader->pNext->pNext->pNext->data);

	struct node *p = pHeader->pNext->pNext->pNext;		// p指向了最后一个节点
	printf("node 3 data: %d.\n", p->data);
	printf("node 2 data: %d.\n", p->pPrev->data);
	printf("node 1 data: %d.\n", p->pPrev->pPrev->data);
	*/
	
	//bianli(pHeader);
	
	struct node *p = pHeader->pNext->pNext->pNext;
	qianxiang_bianli(p);
	
	
	return 0;
}

4.9.12.双链表的算法之删除节点

#include <stdio.h>
#include <stdlib.h>


// 双链表的节点
struct node 
{
	int data;					// 有效数据
	struct node *pPrev;			// 前向指针，指向前一个节点
	struct node *pNext;			// 后向指针，指向后一个节点
};

struct node *create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	p->data = data;
	p->pPrev = NULL;
	p->pNext = NULL;		// 默认创建的节点前向后向指针都指向NULL
	
	return p;
}

// 将新节点new插入到链表pH的尾部
void insert_tail(struct node *pH, struct node *new)
{
	// 第一步先走到链表的尾节点
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;			// 第一次循环走过了头节点
	}
	// 循环结束后p就指向了原来的最后一个节点
	// 第二步：将新节点插入到原来的尾节点的后面
	p->pNext = new;				// 后向指针关联好了。新节点的地址和前节点的next
	new->pPrev = p;				// 前向指针关联好了。新节点的prev和前节点的地址
								// 前节点的prev和新节点的next指针未变动
}

// 将新节点new前插入链表pH中。
// 算法参照图示进行连接，一共有4个指针需要赋值。注意的是顺序。
void insert_head(struct node *pH, struct node *new)
{
	// 新节点的next指针指向原来的第1个有效节点的地址
	new->pNext = pH->pNext;
	
	// 原来第1个有效节点的prev指针指向新节点的地址
	if (NULL != pH->pNext)
		pH->pNext->pPrev = new;
	
	// 头节点的next指针指向新节点地址
	pH->pNext = new;
	
	// 新节点的prev指针指向头节点的地址
	new->pPrev = pH;
}

// 后向遍历一个双链表
void bianli(struct node *pH)
{
	struct node *p = pH;
	
	if (NULL == p)
	{
		return;
	}
	
	while (NULL != p->pNext)
	{
		p = p->pNext;
		
		printf("data = %d.\n", p->data);
	}
}

// 前向遍历一个双遍历，参数pTail要指向链表末尾
void qianxiang_bianli(struct node *pTail)
{
	struct node *p = pTail;
	
	while (NULL != p->pPrev)
	{
		printf("data = %d.\n", p->data);
		
		p = p->pPrev;
	}
}

// 从链表pH中删除一个节点，节点中的数据是data
int delete_node(struct node *pH, int data)
{
	struct node *p = pH;
	
	if (NULL == p)
	{
		return -1;
	}
	
	while (NULL != p->pNext)
	{
		p = p->pNext;
		
		// 在这里先判断当前节点是不是我们要删除的那个节点
		if (p->data == data)
		{
			// 找到了，删除之。当前上下文是：当前节点为p
			if (NULL == p->pNext)
			{
				// 尾节点
// p表示当前节点地址，p->pNext表示后一个节点地址，p->pPrev表示前一个节点的地址
				p->pPrev->pNext = NULL;
				//p->pPrev = NULL;			可以省略，因为后面整个都被销毁了
				// 销毁p节点
				//free(p);
			}
			else
			{
				// 不是尾节点，普通节点
				
				// 前一个节点的next指针指向后一个节点的首地址
				p->pPrev->pNext = p->pNext;
				
				// 当前节点的prev和next指针都不用管，因为后面会整体销毁整个节点
				
				// 后一个节点的prev指针指向前一个节点的首地址
				p->pNext->pPrev = p->pPrev;
				
				//free(p);
			}
			free(p);
			
			return 0;
		}
	}
	
	printf("未找到目标节点.\n");
	return -1;
}



int main(void)
{
	struct node *pHeader = create_node(0);		// 头指针
	//struct node *pHeader = NULL;
	
	insert_head(pHeader, create_node(11));
	insert_head(pHeader, create_node(12));
	insert_head(pHeader, create_node(13));
	
	
	/*
	// 遍历
	printf("node 1 data: %d.\n", pHeader->pNext->data);
	printf("node 2 data: %d.\n", pHeader->pNext->pNext->data);
	printf("node 3 data: %d.\n", pHeader->pNext->pNext->pNext->data);

	struct node *p = pHeader->pNext->pNext->pNext;		// p指向了最后一个节点
	printf("node 3 data: %d.\n", p->data);
	printf("node 2 data: %d.\n", p->pPrev->data);
	printf("node 1 data: %d.\n", p->pPrev->pPrev->data);
	*/
	
	//bianli(pHeader);
	
	//struct node *p = pHeader->pNext->pNext->pNext;
	//qianxiang_bianli(p);
	
	
	bianli(pHeader);
	delete_node(pHeader, 11);
	printf("after delete node------------------\n");
	bianli(pHeader);
	
	return 0;
}

4.9.13.linux内核链表
4.9.13.1、前述链表数据区域的局限性
(1)之前定义数据区域时直接int data;我们认为我们的链表中需要存储的是一个int类型的数。但是实际上现实编程中链接中的节点不可能这么简单，而是多种多样的。
(2)一般实际项目中的链表，节点中存储的数据其实是一个结构体，这个结构体中包含若干的成员，这些成员加起来构成了我们的节点数据区域。

4.9.13.2、一般性解决思路：数据区封装为一个结构体
(1)因为链表实际解决的问题是多种多样的，所以内部数据区域的结构体构成也是多种多样的。这样也导致了不同程序当中的链表总体构成是多种多样的。导致的问题是：我们无法通过一个泛性的、普遍适用的操作函数来访问所有的链表。这就意味着我们设计一个链表就得写一套链表的操作函数（节点创建、插入、删除、遍历······）
(2)实际上深层次分析会发现：不同的链表虽然这些方法不能通用需要单独写，但是实际上内部的思路和方法是相同的，只是函数的局部地区有不同。（实际上链表操作是相同的，而涉及到数据区域的操作就有不同）
(3)鉴于以上2点：我们的理念就是，能不能有一种办法把所有链表中操作方法里共同的部分提取出来用一套标准方法实现，然后把不同的部分留着让具体链表的实现者自己去处理。

4.9.13.3、内核链表的设计思路
(1)内核链表中自己实现了一个纯链表（纯链表就是没有数据区域，只有前后向指针）的封装，以及纯链表的各种操作函数（节点创建、插入、删除、遍历······）。这个纯链表本身自己没有任何用处，它的用法是给我们具体链表作为核心来调用。

4.9.13.4、list.h文件简介
(1)内核中核心纯链表的实现在include/linux/list.h文件中
(2)list.h中就是一个纯链表的完整封装，包含节点定义和各种链表操作方法。

#ifndef _LINUX_LIST_H
#define _LINUX_LIST_H

#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/poison.h>
#include <linux/const.h>
#include <linux/kernel.h>

/*
 * Simple doubly linked list implementation.
 *
 * Some of the internal functions ("__xxx") are useful when
 * manipulating whole lists rather than single entries, as
 * sometimes we already know the next/prev entries and we can
 * generate better code by using them directly rather than
 * using the generic single-entry routines.
 */

#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
	struct list_head name = LIST_HEAD_INIT(name)

static inline void INIT_LIST_HEAD(struct list_head *list)
{
	list->next = list;
	list->prev = list;
}

/*
 * Insert a new entry between two known consecutive entries.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
#ifndef CONFIG_DEBUG_LIST
static inline void __list_add(struct list_head *new,
			      struct list_head *prev,
			      struct list_head *next)
{
	next->prev = new;
	new->next = next;
	new->prev = prev;
	prev->next = new;
}
#else
extern void __list_add(struct list_head *new,
			      struct list_head *prev,
			      struct list_head *next);
#endif

/**
 * list_add - add a new entry
 * @new: new entry to be added
 * @head: list head to add it after
 *
 * Insert a new entry after the specified head.
 * This is good for implementing stacks.
 */
static inline void list_add(struct list_head *new, struct list_head *head)
{
	__list_add(new, head, head->next);
}


/**
 * list_add_tail - add a new entry
 * @new: new entry to be added
 * @head: list head to add it before
 *
 * Insert a new entry before the specified head.
 * This is useful for implementing queues.
 */
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
	__list_add(new, head->prev, head);
}

/*
 * Delete a list entry by making the prev/next entries
 * point to each other.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
	next->prev = prev;
	WRITE_ONCE(prev->next, next);
}

/**
 * list_del - deletes entry from list.
 * @entry: the element to delete from the list.
 * Note: list_empty() on entry does not return true after this, the entry is
 * in an undefined state.
 */
#ifndef CONFIG_DEBUG_LIST
static inline void __list_del_entry(struct list_head *entry)
{
	__list_del(entry->prev, entry->next);
}

static inline void list_del(struct list_head *entry)
{
	__list_del(entry->prev, entry->next);
	entry->next = LIST_POISON1;
	entry->prev = LIST_POISON2;
}
#else
extern void __list_del_entry(struct list_head *entry);
extern void list_del(struct list_head *entry);
#endif

/**
 * list_replace - replace old entry by new one
 * @old : the element to be replaced
 * @new : the new element to insert
 *
 * If @old was empty, it will be overwritten.
 */
static inline void list_replace(struct list_head *old,
				struct list_head *new)
{
	new->next = old->next;
	new->next->prev = new;
	new->prev = old->prev;
	new->prev->next = new;
}

static inline void list_replace_init(struct list_head *old,
					struct list_head *new)
{
	list_replace(old, new);
	INIT_LIST_HEAD(old);
}

/**
 * list_del_init - deletes entry from list and reinitialize it.
 * @entry: the element to delete from the list.
 */
static inline void list_del_init(struct list_head *entry)
{
	__list_del_entry(entry);
	INIT_LIST_HEAD(entry);
}

/**
 * list_move - delete from one list and add as another's head
 * @list: the entry to move
 * @head: the head that will precede our entry
 */
static inline void list_move(struct list_head *list, struct list_head *head)
{
	__list_del_entry(list);
	list_add(list, head);
}

/**
 * list_move_tail - delete from one list and add as another's tail
 * @list: the entry to move
 * @head: the head that will follow our entry
 */
static inline void list_move_tail(struct list_head *list,
				  struct list_head *head)
{
	__list_del_entry(list);
	list_add_tail(list, head);
}

/**
 * list_is_last - tests whether @list is the last entry in list @head
 * @list: the entry to test
 * @head: the head of the list
 */
static inline int list_is_last(const struct list_head *list,
				const struct list_head *head)
{
	return list->next == head;
}

/**
 * list_empty - tests whether a list is empty
 * @head: the list to test.
 */
static inline int list_empty(const struct list_head *head)
{
	return head->next == head;
}

/**
 * list_empty_careful - tests whether a list is empty and not being modified
 * @head: the list to test
 *
 * Description:
 * tests whether a list is empty _and_ checks that no other CPU might be
 * in the process of modifying either member (next or prev)
 *
 * NOTE: using list_empty_careful() without synchronization
 * can only be safe if the only activity that can happen
 * to the list entry is list_del_init(). Eg. it cannot be used
 * if another CPU could re-list_add() it.
 */
static inline int list_empty_careful(const struct list_head *head)
{
	struct list_head *next = head->next;
	return (next == head) && (next == head->prev);
}

/**
 * list_rotate_left - rotate the list to the left
 * @head: the head of the list
 */
static inline void list_rotate_left(struct list_head *head)
{
	struct list_head *first;

	if (!list_empty(head)) {
		first = head->next;
		list_move_tail(first, head);
	}
}

/**
 * list_is_singular - tests whether a list has just one entry.
 * @head: the list to test.
 */
static inline int list_is_singular(const struct list_head *head)
{
	return !list_empty(head) && (head->next == head->prev);
}

static inline void __list_cut_position(struct list_head *list,
		struct list_head *head, struct list_head *entry)
{
	struct list_head *new_first = entry->next;
	list->next = head->next;
	list->next->prev = list;
	list->prev = entry;
	entry->next = list;
	head->next = new_first;
	new_first->prev = head;
}

/**
 * list_cut_position - cut a list into two
 * @list: a new list to add all removed entries
 * @head: a list with entries
 * @entry: an entry within head, could be the head itself
 *	and if so we won't cut the list
 *
 * This helper moves the initial part of @head, up to and
 * including @entry, from @head to @list. You should
 * pass on @entry an element you know is on @head. @list
 * should be an empty list or a list you do not care about
 * losing its data.
 *
 */
static inline void list_cut_position(struct list_head *list,
		struct list_head *head, struct list_head *entry)
{
	if (list_empty(head))
		return;
	if (list_is_singular(head) &&
		(head->next != entry && head != entry))
		return;
	if (entry == head)
		INIT_LIST_HEAD(list);
	else
		__list_cut_position(list, head, entry);
}

static inline void __list_splice(const struct list_head *list,
				 struct list_head *prev,
				 struct list_head *next)
{
	struct list_head *first = list->next;
	struct list_head *last = list->prev;

	first->prev = prev;
	prev->next = first;

	last->next = next;
	next->prev = last;
}

/**
 * list_splice - join two lists, this is designed for stacks
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 */
static inline void list_splice(const struct list_head *list,
				struct list_head *head)
{
	if (!list_empty(list))
		__list_splice(list, head, head->next);
}

/**
 * list_splice_tail - join two lists, each list being a queue
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 */
static inline void list_splice_tail(struct list_head *list,
				struct list_head *head)
{
	if (!list_empty(list))
		__list_splice(list, head->prev, head);
}

/**
 * list_splice_init - join two lists and reinitialise the emptied list.
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 *
 * The list at @list is reinitialised
 */
static inline void list_splice_init(struct list_head *list,
				    struct list_head *head)
{
	if (!list_empty(list)) {
		__list_splice(list, head, head->next);
		INIT_LIST_HEAD(list);
	}
}

/**
 * list_splice_tail_init - join two lists and reinitialise the emptied list
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 *
 * Each of the lists is a queue.
 * The list at @list is reinitialised
 */
static inline void list_splice_tail_init(struct list_head *list,
					 struct list_head *head)
{
	if (!list_empty(list)) {
		__list_splice(list, head->prev, head);
		INIT_LIST_HEAD(list);
	}
}

/**
 * list_entry - get the struct for this entry
 * @ptr:	the &struct list_head pointer.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_head within the struct.
 */
#define list_entry(ptr, type, member) \
	container_of(ptr, type, member)

/**
 * list_first_entry - get the first element from a list
 * @ptr:	the list head to take the element from.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_head within the struct.
 *
 * Note, that list is expected to be not empty.
 */
#define list_first_entry(ptr, type, member) \
	list_entry((ptr)->next, type, member)

/**
 * list_last_entry - get the last element from a list
 * @ptr:	the list head to take the element from.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_head within the struct.
 *
 * Note, that list is expected to be not empty.
 */
#define list_last_entry(ptr, type, member) \
	list_entry((ptr)->prev, type, member)

/**
 * list_first_entry_or_null - get the first element from a list
 * @ptr:	the list head to take the element from.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_head within the struct.
 *
 * Note that if the list is empty, it returns NULL.
 */
#define list_first_entry_or_null(ptr, type, member) \
	(!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL)

/**
 * list_next_entry - get the next element in list
 * @pos:	the type * to cursor
 * @member:	the name of the list_head within the struct.
 */
#define list_next_entry(pos, member) \
	list_entry((pos)->member.next, typeof(*(pos)), member)

/**
 * list_prev_entry - get the prev element in list
 * @pos:	the type * to cursor
 * @member:	the name of the list_head within the struct.
 */
#define list_prev_entry(pos, member) \
	list_entry((pos)->member.prev, typeof(*(pos)), member)

/**
 * list_for_each	-	iterate over a list
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 */
#define list_for_each(pos, head) \
	for (pos = (head)->next; pos != (head); pos = pos->next)

/**
 * list_for_each_prev	-	iterate over a list backwards
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 */
#define list_for_each_prev(pos, head) \
	for (pos = (head)->prev; pos != (head); pos = pos->prev)

/**
 * list_for_each_safe - iterate over a list safe against removal of list entry
 * @pos:	the &struct list_head to use as a loop cursor.
 * @n:		another &struct list_head to use as temporary storage
 * @head:	the head for your list.
 */
#define list_for_each_safe(pos, n, head) \
	for (pos = (head)->next, n = pos->next; pos != (head); \
		pos = n, n = pos->next)

/**
 * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
 * @pos:	the &struct list_head to use as a loop cursor.
 * @n:		another &struct list_head to use as temporary storage
 * @head:	the head for your list.
 */
#define list_for_each_prev_safe(pos, n, head) \
	for (pos = (head)->prev, n = pos->prev; \
	     pos != (head); \
	     pos = n, n = pos->prev)

/**
 * list_for_each_entry	-	iterate over list of given type
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 */
#define list_for_each_entry(pos, head, member)				\
	for (pos = list_first_entry(head, typeof(*pos), member);	\
	     &pos->member != (head);					\
	     pos = list_next_entry(pos, member))

/**
 * list_for_each_entry_reverse - iterate backwards over list of given type.
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 */
#define list_for_each_entry_reverse(pos, head, member)			\
	for (pos = list_last_entry(head, typeof(*pos), member);		\
	     &pos->member != (head); 					\
	     pos = list_prev_entry(pos, member))

/**
 * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
 * @pos:	the type * to use as a start point
 * @head:	the head of the list
 * @member:	the name of the list_head within the struct.
 *
 * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
 */
#define list_prepare_entry(pos, head, member) \
	((pos) ? : list_entry(head, typeof(*pos), member))

/**
 * list_for_each_entry_continue - continue iteration over list of given type
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 *
 * Continue to iterate over list of given type, continuing after
 * the current position.
 */
#define list_for_each_entry_continue(pos, head, member) 		\
	for (pos = list_next_entry(pos, member);			\
	     &pos->member != (head);					\
	     pos = list_next_entry(pos, member))

/**
 * list_for_each_entry_continue_reverse - iterate backwards from the given point
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 *
 * Start to iterate over list of given type backwards, continuing after
 * the current position.
 */
#define list_for_each_entry_continue_reverse(pos, head, member)		\
	for (pos = list_prev_entry(pos, member);			\
	     &pos->member != (head);					\
	     pos = list_prev_entry(pos, member))

/**
 * list_for_each_entry_from - iterate over list of given type from the current point
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 *
 * Iterate over list of given type, continuing from current position.
 */
#define list_for_each_entry_from(pos, head, member) 			\
	for (; &pos->member != (head);					\
	     pos = list_next_entry(pos, member))

/**
 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 */
#define list_for_each_entry_safe(pos, n, head, member)			\
	for (pos = list_first_entry(head, typeof(*pos), member),	\
		n = list_next_entry(pos, member);			\
	     &pos->member != (head); 					\
	     pos = n, n = list_next_entry(n, member))

/**
 * list_for_each_entry_safe_continue - continue list iteration safe against removal
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 *
 * Iterate over list of given type, continuing after current point,
 * safe against removal of list entry.
 */
#define list_for_each_entry_safe_continue(pos, n, head, member) 		\
	for (pos = list_next_entry(pos, member), 				\
		n = list_next_entry(pos, member);				\
	     &pos->member != (head);						\
	     pos = n, n = list_next_entry(n, member))

/**
 * list_for_each_entry_safe_from - iterate over list from current point safe against removal
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 *
 * Iterate over list of given type from current point, safe against
 * removal of list entry.
 */
#define list_for_each_entry_safe_from(pos, n, head, member) 			\
	for (n = list_next_entry(pos, member);					\
	     &pos->member != (head);						\
	     pos = n, n = list_next_entry(n, member))

/**
 * list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_head within the struct.
 *
 * Iterate backwards over list of given type, safe against removal
 * of list entry.
 */
#define list_for_each_entry_safe_reverse(pos, n, head, member)		\
	for (pos = list_last_entry(head, typeof(*pos), member),		\
		n = list_prev_entry(pos, member);			\
	     &pos->member != (head); 					\
	     pos = n, n = list_prev_entry(n, member))

/**
 * list_safe_reset_next - reset a stale list_for_each_entry_safe loop
 * @pos:	the loop cursor used in the list_for_each_entry_safe loop
 * @n:		temporary storage used in list_for_each_entry_safe
 * @member:	the name of the list_head within the struct.
 *
 * list_safe_reset_next is not safe to use in general if the list may be
 * modified concurrently (eg. the lock is dropped in the loop body). An
 * exception to this is if the cursor element (pos) is pinned in the list,
 * and list_safe_reset_next is called after re-taking the lock and before
 * completing the current iteration of the loop body.
 */
#define list_safe_reset_next(pos, n, member)				\
	n = list_next_entry(pos, member)

/*
 * Double linked lists with a single pointer list head.
 * Mostly useful for hash tables where the two pointer list head is
 * too wasteful.
 * You lose the ability to access the tail in O(1).
 */

#define HLIST_HEAD_INIT { .first = NULL }
#define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
static inline void INIT_HLIST_NODE(struct hlist_node *h)
{
	h->next = NULL;
	h->pprev = NULL;
}

static inline int hlist_unhashed(const struct hlist_node *h)
{
	return !h->pprev;
}

static inline int hlist_empty(const struct hlist_head *h)
{
	return !h->first;
}

static inline void __hlist_del(struct hlist_node *n)
{
	struct hlist_node *next = n->next;
	struct hlist_node **pprev = n->pprev;

	WRITE_ONCE(*pprev, next);
	if (next)
		next->pprev = pprev;
}

static inline void hlist_del(struct hlist_node *n)
{
	__hlist_del(n);
	n->next = LIST_POISON1;
	n->pprev = LIST_POISON2;
}

static inline void hlist_del_init(struct hlist_node *n)
{
	if (!hlist_unhashed(n)) {
		__hlist_del(n);
		INIT_HLIST_NODE(n);
	}
}

static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
{
	struct hlist_node *first = h->first;
	n->next = first;
	if (first)
		first->pprev = &n->next;
	h->first = n;
	n->pprev = &h->first;
}

/* next must be != NULL */
static inline void hlist_add_before(struct hlist_node *n,
					struct hlist_node *next)
{
	n->pprev = next->pprev;
	n->next = next;
	next->pprev = &n->next;
	*(n->pprev) = n;
}

static inline void hlist_add_behind(struct hlist_node *n,
				    struct hlist_node *prev)
{
	n->next = prev->next;
	prev->next = n;
	n->pprev = &prev->next;

	if (n->next)
		n->next->pprev  = &n->next;
}

/* after that we'll appear to be on some hlist and hlist_del will work */
static inline void hlist_add_fake(struct hlist_node *n)
{
	n->pprev = &n->next;
}

static inline bool hlist_fake(struct hlist_node *h)
{
	return h->pprev == &h->next;
}

/*
 * Move a list from one list head to another. Fixup the pprev
 * reference of the first entry if it exists.
 */
static inline void hlist_move_list(struct hlist_head *old,
				   struct hlist_head *new)
{
	new->first = old->first;
	if (new->first)
		new->first->pprev = &new->first;
	old->first = NULL;
}

#define hlist_entry(ptr, type, member) container_of(ptr,type,member)

#define hlist_for_each(pos, head) \
	for (pos = (head)->first; pos ; pos = pos->next)

#define hlist_for_each_safe(pos, n, head) \
	for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
	     pos = n)

#define hlist_entry_safe(ptr, type, member) \
	({ typeof(ptr) ____ptr = (ptr); \
	   ____ptr ? hlist_entry(____ptr, type, member) : NULL; \
	})

/**
 * hlist_for_each_entry	- iterate over list of given type
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry(pos, head, member)				\
	for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member);\
	     pos;							\
	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))

/**
 * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
 * @pos:	the type * to use as a loop cursor.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry_continue(pos, member)			\
	for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member);\
	     pos;							\
	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))

/**
 * hlist_for_each_entry_from - iterate over a hlist continuing from current point
 * @pos:	the type * to use as a loop cursor.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry_from(pos, member)				\
	for (; pos;							\
	     pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))

/**
 * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 * @pos:	the type * to use as a loop cursor.
 * @n:		another &struct hlist_node to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the hlist_node within the struct.
 */
#define hlist_for_each_entry_safe(pos, n, head, member) 		\
	for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\
	     pos && ({ n = pos->member.next; 1; });			\
	     pos = hlist_entry_safe(n, typeof(*pos), member))

#endif

4.9.14.内核链表的基本算法和使用简介
4.9.14.1、内核链表的节点创建、删除、遍历等
4.9.14.2、内核链表的使用实践
(1)问题：内核链表只有纯链表，没有数据区域，怎么使用？
(2)设计的使用方法是将内核链表作为将来整个数据结构的结构体的一个成员内嵌进去。

#include <linux/list.h>



struct driver_info
{
	int data;
};

// driver结构体用来管理内核中的驱动
struct driver
{
	char name[20];				// 驱动名称
	int id;						// 驱动id编号
	struct driver_info info;	// 驱动信息
	struct list_head head;		// 内嵌的内核链表成员
};

struct driver2
{
	char name[20];				// 驱动名称
	int id;						// 驱动id编号
	struct driver_info info;	// 驱动信息
	//struct list_head head;		// 内嵌的内核链表成员
	struct driver *prev;
	struct driver *next;
};

// 分析driver结构体，可知：前三个成员都是数据区域成员（就是我们之前简化为int data的东西），第4个成员是一个struct list_head类型的变量，这就是一个纯链表。
// 本来driver结构体是没有链表的，也无法用链表来管理。但是我们driver内嵌的head成员本身就是一个纯链表，所以driver通过head成员给自己扩展了链表的功能。
// driver通过内嵌的方式扩展链表成员，本身不只是有了一个链表成员，关键是可以通过利用list_head本身事先实现的链表的各种操作方法来操作head。

// 最终效果：我们可以通过遍历head来实现driver的遍历；遍历head的函数在list.h中已经事先写好了，所以我们内核中去遍历driver时就不用重复去写了。
// 通过操作head来操作driver，实质上就是通过操作结构体的某个成员变量来操作整个结构体变量。这里面要借助container_of宏

4.9.15.什么是状态机
4.9.15.1、有限状态机
(1)常说的状态机是有限状态机FSM。FSM指的是有有限个状态（一般是一个状态变量的值），这个机器同时能够从外部接收信号和信息输入，机器在接收到外部输入的信号后会综合考虑当前自己的状态和用户输入的信息，然后机器做出动作：跳转到另一个状态。
(2)考虑状态机的关键点：当前状态、外部输入、下一个状态
4.9.15.2、两种状态机：Moore型和Mealy型
(1)Moore型状态机特点是：输出只与当前状态有关（与输入信号无关）。相对简单，考虑状态机的下一个状态时只需要考虑它的当前状态就行了。
(2)Mealy型状态机的特点是：输出不只和当前状态有关，还与输入信号有关。状态机接收到一个输入信号需要跳转到下一个状态时，状态机综合考虑2个条件（当前状态、输入值）后才决定跳转到哪个状态。
4.9.15.3、状态机的主要用途：电路设计、FPGA程序设计、软件设计
(1)电路设计中广泛使用了状态机思想
(2)FPGA程序设计
(3)软件设计（框架类型的设计，譬如操作系统的GUI系统、消息机制）

4.9.15.4、状态机解决了什么问题
(1)我们平时写程序都是顺序执行的，这种程序有个特点：程序的大体执行流程是既定的，程序的执行是遵照一定的大的方向有迹可寻的。
(2)但是偶尔会碰到这样的程序：外部不一定会按照既定流程来给程序输入信息，而程序还需要完全能够接收并响应外部的这些输入信号，还要能做出符合逻辑的输出。

4.9.16.C语言实现简单的状态机
4.9.16.1、题目：开锁状态机。功能描述：用户连续输入正确的密码则会开锁，如果密码输入过程错误则锁会退回到初始状态重新计入密码，即：用户只需要连续输入出正确的密码即可开锁（输入错误不用撤销、也不用删除）
4.9.16.2、题目分析

#include <stdio.h>


// 给状态机定义状态集
typedef enum 
{
	STATE1,
	STATE2,
	STATE3,
	STATE4,
	STATE5,
	STATE6,
	STATE7,
}STATE;


int main(void)
{
	int num = 0;
	// current_state记录状态机的当前状态，初始为STATE1，用户每输入一个正确的
	// 密码STATE就走一步，一直到STATE为STATE7后锁就开了；其中只要有一次用户
	// 输入对不上就回到STATE1.
	STATE current_state = STATE1;		// 状态机初始状态为STATE1
	
	// 第一步：实现一个用户循环输入密码的循环
	printf("请输入密码，密码正确开锁.\n");
	while (1)
	{
		scanf("%d", &num);
		printf("num = %d.\n", num);
		
		// 在这里处理用户的本次输入
		switch (current_state)
		{
			case STATE1:
				if (num == 1)
				{
					current_state = STATE2;		// 用户输入对了一步，STATE走一步
				}
				else
				{
					current_state = STATE1;
				}
				break;
			case STATE2:
				if (num == 2)
				{
					current_state = STATE3;		// 用户输入对了一步，STATE走一步
				}
				else
				{
					current_state = STATE1;
				}
				break;
			case STATE3:
				if (num == 3)
				{
					current_state = STATE4;		// 用户输入对了一步，STATE走一步
				}
				else
				{
					current_state = STATE1;
				}
				break;
			case STATE4:
				if (num == 4)
				{
					current_state = STATE5;		// 用户输入对了一步，STATE走一步
				}
				else
				{
					current_state = STATE1;
				}
				break;
			case STATE5:
				if (num == 5)
				{
					current_state = STATE6;		// 用户输入对了一步，STATE走一步
				}
				else
				{
					current_state = STATE1;
				}
				break;
			case STATE6:
				if (num == 6)
				{
					current_state = STATE7;		// 用户输入对了一步，STATE走一步
				}
				else
				{
					current_state = STATE1;
				}
				break;
			default:
				current_state = STATE1;
		}
		
		if (current_state == STATE7)
		{
			printf("锁开了.\n");
			break;
		}
	}
	
	
	return 0;
}

4.9.17.多线程简介
4.9.17.1、操作系统下的并行执行机制
(1)并行就是说多个任务同时被执行。并行分微观上的并行和宏观上的并行。
(2)宏观上的并行就是从长时间段（相对于人来说）来看，多个任务是同时进行的；微观上的并行就是真的在并行执行。
(3)操作系统要求实现宏观上的并行。宏观上的并行有2种情况：第一种是微观上的串行，第二种是微观上的并行。
(4)理论来说，单核CPU本身只有一个核心，同时只能执行一条指令，这种CPU只能实现宏观上的并行，微观上一定是串行的。微观上的并行要求多核心CPU。多核CPU中的多个核心可以同时微观上执行多个指令，因此可以达到微观上的并行，从而提升宏观上的并行度。

4.9.17.2、进程和线程的区别和联系
(1)进程和线程是操作系统的两种不同软件技术，目的是实现宏观上的并行（通俗一点就是让多个程序同时在一个机器上运行，达到宏观上看起来并行执行的效果）。
(2)进程和线程在实现并行效果的原理上不同。而且这个差异和操作系统有关。譬如windows中进程和线程差异比较大，在linux中进程和线程差异不大（linux中线程就是轻量级的进程）。
(3)不管是多进程还是多线程，最终目标都是实现并行执行。

4.9.17.3、多线程的优势
(1)前些年多进程多一些，近些年多线程开始用得多。
(2)现代操作系统设计时考虑到了多核心CPU的优化问题，保证了：多线程程序在运行的时候，操作系统会优先将多个线程放在多个核心中分别单独运行。所以说多核心CPU给多线程程序提供了完美的运行环境。所以在多核心CPU上使用多线程程序有极大的好处。

4.9.17.4、线程同步和锁
(1)多线程程序运行时要注意线程之间的同步。

4.9.17.5、详细情况敬请期待：《3.linux应用编程和网络编程》