链表的引入
从数组的缺陷说起
- 数组有2个缺陷：一个是数组中所有元素的类型必须一致；第二个是数组的元素个数必须事先制定并且一旦指定之后不能更改。
- 如何解决数组的2个缺陷：数组的第一个缺陷靠结构体去解决。结构体允许其中的元素的类型不相同，因此解决了数组的第一个缺陷。所以说结构体是因为数组不能解决某些问题所以才发明的。
- 如何解决数组的第二个缺陷？我们希望数组的大小能够实时扩展。譬如我刚开始定了一个元素个数是10，后来程序运行时觉得不够因此动态扩展为20.普通的数组显然不行，我们可以对数组进行封装以达到这种目的；我们还可以使用一个新的数据结构来解决，这个新的数据结构就是链表。
- 总结：几乎可以这样理解：链表就是一个元素个数可以实时变大/变小的数组。
大学为什么都有新校区？
- 学校初建的时候（类似于变量定义并初始化时），这时候因为旁边都是荒地而没有建筑，因此学校的校园大小由自己定的；但是学校建立了之后旁边慢慢的也有了其他建筑（类似于这个变量分配了之后，内存的相邻区域又分配了其他变量与这个变量地址相连），这时候你的校园随着发展感觉不够用了想要扩展，却发现邻居已经住满了，校园的四周全部都是别人的建筑，这时候学校要扩展有2个办法：第一个是拆迁，第二个是搬迁，第三个是外部扩展。
- 拆迁基本行不通，因为成本太高了。
- 搬迁可以行的通。程序中解决数组大小扩展的一个思路就是整体搬迁。具体步骤是：先在另外的空白内存处建立一个大的数组，然后把原来的数组中的元素的值整个复制到新数组的头部，然后再释放掉原来数组的内存空间，并且把新的数组去替代原来的数组。这种可变数组在C语言中不支持，但是在更高级语言如C++、Java等里面是支持的。
- 外部扩展的思路是最常见的，基本可以说是最合理的。它的一个思路就是化整为零，在原来的不动的前提下去外部扩展新的分基地。外部扩展在学校的例子中就是新校区；外部扩展在编程解决数组问题的点上就是链表。
链表是什么样的？
- 顾名思义，链表就是用锁链连接起来的表。这里的表指的是一个一个的节点（一个节点就是一个校区），节点中有一些内存可以用来存储数据（所以叫表，表就是数据表）；这里的锁链指的是链接各个表的方法，C语言中用来连接2个表（其实就是2块内存）的方法就是指针。
- 链表是由若干个节点组成的（链表的各个节点结构是完全类似的），节点由有效数据和指针组成。有效数据区域用来存储信息完成任务的，指针区域用于指向链表的下一个节点从而构成链表。
时刻别忘了链表是用来干嘛的
- 时刻谨记：链表就是用来解决数组的大小不能动态扩展的问题，所以链表其实就是当数组用的。直白点：链表能完成的任务用数组也能完成，数组能完成的任务用链表也能完成。但是灵活性不一样。
- 简单说：链表就是用来存储数据的。链表用来存数据相对于数组来说优点就是灵活性，需要多少个动态分配多少个，不占用额外的内存。数组的优势是使用简单（简单粗暴）。
单链表的实现
单链表的节点构成
- 链表是由节点组成的，节点中包含：有效数据和指针。
- 定义的struct link只是一个结构体，本身并没有变量生成，也不占用内存。结构体定义相当于为链表节点定义了一个模板，但是还没有一个节点，将来在实际创建链表时需要一个节点时用这个模板来复制一个即可。
struct link
{
int data; // 定义一个有效数据
struct link *pNext; // 指向下一个节点
};
堆内存的申请和使用
- 链表的内存要求比较灵活，不能用栈，也不能用data数据段（开机分配）。只能用堆内存。（既 内存无限多，能随意删除，）
- 使用堆内存来创建一个链表节点的步骤：
- 申请堆内存，大小为一个节点的大小（检查申请结果是否正确）；
- 清理申请到的堆内存；
- 把申请到的堆内存当作一个新节点；
- 填充下个新节点的有效数据和指针区域。
struct link *pHeader = NULL; // 定义一个头指针，指向一个链表
// 创建一个链表节点；每创建一个新节点，就把这个节点和上一个节点关联起来
struct link *p1 = (struct link *)malloc(sizeof(struct link)); // 分配一个结构体大小的内存空间
if(NULL == p1) // 检查指针的有效性
{
printf("malloc *p1 error
");
return -1;
}
memset(p1, ' ', sizeof(struct link));
p1->data = 1; // 给一个节点填充数据
p1->pNext = NULL; // 指向下一个节点的首地址，，由于不知道，所以占时设为NULL，实际操作时将下一个节点malloc的返回值赋值给这个指针
pHeader = p1; // 将这个节点和它前面的头指针关联起来
链表的头指针
- 头指针并不是节点，而是一个普通指针，只占4字节。头指针的类型是struct link*类型的，所以它才能指向链表的节点。
- 一个典型的链表的实现就是：头指针指向链表的第1个节点，然后第1个节点中的指针指向下一个节点，然后依次类推一直到最后一个节点。这样就构成了一个链。
- struct link *pHeader = NULL; // 定义一个头指针，指向一个链表
实战：构建一个简单的单链表
- 目标：构建一个链表，然后将一些数据（譬如1，2，3三个数字）存储在链表中
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct node
{
int data; // 定义一个有效数据
struct node *pNext; // 指向下一个节点
};
int main(void)
{
struct node *pHeader = NULL; // 定义一个头指针，指向一个链表
/****************************************************************************************************/
// 创建一个链表节点；每创建一个新节点，就把这个节点和上一个节点关联起来
struct node *p1 = (struct node *)malloc(sizeof(struct node)); // 分配一个结构体大小的内存空间
if(NULL == p1) // 检查指针的有效性
{
printf("malloc *p1 error
");
return -1;
}
memset(p1, ' ', sizeof(struct node));
p1->data = 1; // 给一个节点填充数据
p1->pNext = NULL; // 指向下一个节点的首地址，，由于不知道，所以占时设为NULL，实际操作时将下一个节点malloc的返回值赋值给这个指针
pHeader = p1; // 将这个节点和它前面的头指针关联起来
/****************************************************************************************************/
/****************************************************************************************************/
// 创建一个链表节点；每创建一个新节点，就把这个节点和上一个节点关联起来
struct node *p2 = (struct node *)malloc(sizeof(struct node)); // 分配一个结构体大小的内存空间
if(NULL == p2) // 检查指针的有效性
{
printf("malloc *p erro
");
return -1;
}
memset(p2, ' ', sizeof(struct node));
p2->data = 2; // 给一个节点填充数据
p2->pNext = NULL; // 指向下一个节点的首地址，，由于不知道，所以占时设为NULL，实际操作时将下一个节点malloc的返回值赋值给这个指针
p1->pNext = p2; // 将这个节点和它前面的头指针关联起来
/****************************************************************************************************/
/****************************************************************************************************/
// 创建一个链表节点；每创建一个新节点，就把这个节点和上一个节点关联起来
struct node *p3 = (struct node *)malloc(sizeof(struct node)); // 分配一个结构体大小的内存空间
if(NULL == p3) // 检查指针的有效性
{
printf("malloc *p3 erro
");
return -1;
}
memset(p3, ' ', sizeof(struct node));
p3->data = 3; // 给一个节点填充数据
p3->pNext = NULL; // 指向下一个节点的首地址，，由于不知道，所以占时设为NULL，实际操作时将下一个节点 malloc的返回值赋值给这个指针
p2->pNext = p3; // 将这个节点和它前面的头指针关联起来
/****************************************************************************************************/
// 访问链表第1个节点的有效数据
printf("node1 data: %d.
", pHeader->data);
printf("p1->data: %d.
", p1->data); // pHeader->data等同于p->data
// 访问链表第2个节点的有效数据
printf("node2 data: %d.
", pHeader->pNext->data);
printf("p2->data: %d.
", p2->data);
// pHeader->pNext->data等同于p1->data
// 访问链表第3个节点的有效数据
printf("node3 data: %d.
", pHeader->pNext->pNext->data);
printf("p3->data: %d.
", p3->data);
// pHeader->pNext->pNext->data等同于p2->data
return 0;
}
单链表的算法之插入节点
访问链表中各个节点的数据
- 只能用头指针，不能用各个节点自己的指针。因为在实际当中我们保存链表的时候是不会保存各个节点的指针的，只能通过头指针来访问链表节点。
- 前一个节点内部的pNext指针能帮助我们找到下一个节点。
封装创建节点函数
- 封装时的关键点就是函数的接口（函数参数和返回值）的设计
struct node * create_node(int data)
{
struct node *pHeader = NULL;
struct node *p = (struct node *)malloc(sizeof(struct node));
if(NULL == p)
{
printf("malloc *p error
");
return NULL;
}
memset(p, ' ', sizeof(struct node));
p->data = data;
p->pNext = NULL;
return p;
}
从链表头部插入新节点
- 在节点的末尾插入一个新的节点。 思路：由头指针向后遍历，直到走到最后一个节点
// 在节点的末尾插入一个新的节点
void insert_fail(struct node *pHeader, struct node *new)
{
struct node *p = pHeader;
while(NULL != p->pNext) // 第一步，在链表中找到最后一个节点
{
p = p->pNext; // 如果不是最后一个节点，级走向下一个节点
}
p->pNext = new; // 第二步，在链表的最后插入一个新节点
}
int main(void)
{
struct node *pHeader = create_node(11); // 没有节点的情况下，先创建一个想新节点
insert_fail(pHeader, create_node(22));
insert_fail(pHeader, create_node(33));
printf("node1 data: %d.
", pHeader->data);
printf("node2 data: %d.
", pHeader->pNext->data);
printf("node3 data: %d.
", pHeader->pNext->pNext->data);
return 0;
}
详解链表头部插入函数
- 什么是头节点
- 问题：因为我们在insert_tail中直接默认了头指针指向的有一个节点，因此如果程序中直接定义了头指针后就直接insert_tail就会报段错误。我们不得不在定义头指针之后先create_link创建一个新节点给头指针初始化，否则不能避免这个错误；但是这样解决让程序看起来逻辑有点不太顺，因为看起来第一个节点和后面的节点的创建、添加方式有点不同。
- 链表还有另外一种用法，就是把头指针指向的第一个节点作为头节点使用。头节点的特点是：第一，它紧跟在头指针后面。第二，头节点的数据部分是空的（有时候不是空的，而是存储整个链表的节点数），指针部分指向下一个节点，也就是第一个节点。
- 这样看来，头节点确实和其他节点不同。我们在创建一个链表时添加节点的方法也不同。头节点在创建头指针时一并创建并且和头指针关联起来；后面的真正的存储数据的节点用节点添加的函数来完成，譬如insert_tail.
// 在节点的末尾插入一个新的节点
void insert_fail(struct node *pHeader, struct node *new)
{
int count = 0;
struct node *p = pHeader;
while(NULL != p->pNext) // 第一步，在链表中找到最后一个节点
{
p = p->pNext; // 如果不是最后一个节点，级走向下一个节点
count ++;
}
p->pNext = new; // 第二步，在链表的最后插入一个新节点
pHeader->data = count+1; // 因为在插入前已经有一个空节点，所以+1
}
int main(void)
{
struct node *pHeader = create_node(0); // 创建一个空节点，假设为0
insert_fail(pHeader, create_node(11));
insert_fail(pHeader, create_node(22));
insert_fail(pHeader, create_node(33));
printf("node0 data: %d.
", pHeader->data);
printf("node1 data: %d.
", pHeader->pNext->data);
printf("node2 data: %d.
", pHeader->pNext->pNext->data);
printf("node3 data: %d.
", pHeader->pNext->pNext->pNext->data);
return 0;
}
- 链表有没有头节点是不同的。体现在链表的插入节点、删除节点、遍历节点、解析链表的各个算法函数都不同。所以如果一个链表设计的时候就有头节点那么后面的所有算法都应该这样来处理；如果设计时就没有头节点，那么后面的所有算法都应该按照没有头节点来做。实际编程中两种链表都有人用，所以大家在看别人写的代码时一定要注意看它有没有头节点。
从链表头部插入新节点
- 注意写代码过程中的箭头符号，和说话过程中的指针指向。这是两码事，容易搞混。箭头符号实际上是用指针方式来访问结构体，所以箭头符号的实质是访问结构体中的成员。更清楚一点说程序中的箭头和链表的连接没有任何关系；链表中的节点通过指针指向来连接，编程中表现为一个赋值语句（用=来进行连接），实质是把后一个节点的首地址，赋值给前一个节点中的pNext元素做为值。
- 链表可以从头部插入，也可以从尾部插入。也可以两头插入。头部插入和尾部插入对链表来说几乎没有差别。对链表本身无差别，但是有时候对业务逻辑有差别。
void insert_head(struct node *pHeader, struct node *new)
{
int count = 0;
new->pNext = pHeader->pNext; // 将新节点的pNext指向第一个节点，与第一个节点建立连接
pHeader->pNext = new; // 将头节点的pNext指向新节点，与头节点建立连接
pHeader->data += count + 1; // 节点数统计
}
int main(void)
{
struct node *pHeader = create_node(0); // 创建一个空节点，假设为0
insert_head(pHeader, create_node(11));
insert_fail(pHeader, create_node(22));
insert_head(pHeader, create_node(33));
printf("node0 data: %d.
", pHeader->data);
printf("node1 data: %d.
", pHeader->pNext->data);
printf("node2 data: %d.
", pHeader->pNext->pNext->data);
printf("node3 data: %d.
", pHeader->pNext->pNext->pNext->data);
return 0;
}
单链表的算法之遍历节点
什么是遍历
- 遍历就是把单链表中的各个节点挨个拿出来，就叫遍历。
- 遍历的要点：一是不能遗漏、二是不能重复、追求效率。
如何遍历单链表
- 分析一个数据结构如何遍历，关键是分析这个数据结构本身的特点。然后根据本身特点来制定它的遍历算法。
- 单链表的特点就是由很多个节点组成，头指针+头节点为整个链表的起始，最后一个节点的特征是它内部的pNext指针值为NULL。从起始到结尾中间由各个节点内部的pNext指针来挂接。由起始到结尾的路径有且只有一条。单链表的这些特点就决定了它的遍历算法。
- 遍历方法：从头指针+头节点开始，顺着链表挂接指针依次访问链表的各个节点，取出这个节点的数据，然后再往下一个节点，直到最后一个节点，结束返回。
编程实战
- 写一个链表遍历的函数，void ergodic(struct link *pHeader)；
// 遍历函数
void ergodic(struct link *pHeader)
{
struct link *p = pHeader;
printf("-----------开始遍历-----------
");
while (NULL != p->pNext) // 是不是最后一个节点
{
p = p->pNext;
printf("ergodic num: %d
", p->data);
}
printf("-----------开始结束-----------
");
}
int main(void)
{
struct link *pHeader = create_link(0); // 创建一个空节点，假设为0
insert_head(pHeader, create_link(11));
insert_fail(pHeader, create_link(22));
insert_head(pHeader, create_link(33));
printf("node0 data: %d.
", pHeader->data);
ergodic(pHeader);
return 0;
}
单链表的算法之删除节点
为什么要删除节点
- 一直在强调，链表到底用来干嘛的？链表使用来存数据的
- 有时候链表节点中的数据不想要了，因此要删掉这个节点。
删除节点的2个步骤
- 第一步：找到要删除的节点；第二步：删除这个节点。
如何找到待删除的节点
- 通过遍历来查找节点。从头指针+头节点开始，顺着链表依次将各个节点拿出来，按照一定的方法比对，找到我们要删除的那个节点。
如何删除一个节点
- 待删除的节点不是尾节点的情况：首先把待删除的节点的前一个节点的pNext指针指向待删除的节点的后一个节点的首地址（这样就把这个节点从链表中摘出来了），然后再将这个摘出来的节点free掉接口。
- 待删除的节点是尾节点的情况：首先把待删除的尾节点的前一个节点的pNext指针指向null（这时候就相当于原来尾节点前面的一个节点变成了新的尾节点），然后将摘出来的节点free掉。
注意堆内存的释放
- 前面几节课我们写的代码最终都没有释放堆内存。当程序都结束了的情况下那些没有free的堆内存也被释放了。
- 有时候我们的程序运行时间很久，这时候malloc的内存如果没有free会一直被占用直到你free释放它或者整个程序终止。
// 删除节点
int delete_node(struct node *pHeader, int data)
{
struct node *p = pHeader; // 定义p指针指向当前节点
struct node *pPrev = NULL; // 定义pPrev指针指向当前节点的前一个节点
while(NULL != p->pNext)
{
pPrev = p; // 将当前节点保存到 pPrev
p = p->pNext; // 移动到下一个节点
if(p->data == data) // 如果这个节点的数据 等于 data
{
if(NULL == p->pNext) // 如果这个节点是尾节点
{
pPrev->pNext = NULL; // 直接将这个节点前一个节点的pNext设置为NULL，并释放内存空间
free(p);
}
else // 如果不是尾节点
{
pPrev->pNext = p->pNext; // 要删除的节点的前一个节点和它的后一个节点相连，
free(p); // 这样就把要删除的节点给摘出来了
}
return 0;
}
}
printf("没有找到
");
return -1;
}
int main(void)
{
struct node *pHeader = create_node(0); // 创建一个空节点，假设为0
insert_head(pHeader, create_node(11));
insert_fail(pHeader, create_node(22));
insert_head(pHeader, create_node(33));
printf("node0 data: %d.
", pHeader->data);
ergodic(pHeader);
delete_node(pHeader, 11);
printf("------------------删除后-------------
");
ergodic(pHeader);
return 0;
}
单链表的算法之逆序
什么是链表的逆序
- 链表的逆序又叫反向，意思就是把链表中所有的有效节点在链表中的顺序给反过来。
单链表逆序算法分析
- 当我们对一个数据结构进行一个操作时，我们就需要一套算法。这就是数据结构和算法的关系。
- 总结：算法有2个层次。第一个层次是数学和逻辑上的算法；第二次个层次是用编程语言来实现算法。
- 从逻辑上来讲，链表的逆序有很多种方法。这些方法都能实现最终的需要，但是效率是不一样的。彼此的可扩展性、容错性等不同。
- 思路：首先遍历原链表，然后将原链表中的头指针和头节点作为新链表的头指针和头节点，原链表中的有效节点挨个依次取出来，采用头插入的方法插入新链表中即可。
- 链表逆序 = 遍历 + 头插入
编程实战
方法一：
/* 链表逆序 */
void reverse_list(struct node *pHeader)
{
struct node *p = pHeader->pNext; /* pHeader指向头节点，ｐ指向第一个有效节点 */
struct node *pSave = NULL; /* 保存当前节点的后一个节点地址 */
/* 当链表没有有效节点或者只有一个有效节点时逆序不做任何操作 */
if((NULL == p) || (NULL == pHeader->pNext))
return;
/* 两个及两个以上节点时，使用逆序操作 */
while(NULL != p->pNext) /* 判断是否时最后一个节点 */
{
pSave = p->pNext;
if(p == pHeader->pNext) /* 原链表中的第一个有效节点将是逆序后的链表的尾节点，尾节点的pNext指向NULL */
{
p->pNext = NULL;
}
else
{
p->pNext = pHeader->pNext; /* 原链表的非第一个节点 */
}
pHeader->pNext = p;
p = pSave;
}
insert_head(pHeader, p); /* 循环结束后，最后一个节点仍然缺失 */
}
方法二：
// struct node *ReverseSinglyLinkedList(struct node *pHeader)
void ReverseSinglyLinkedList(struct node *pHeader)
{
struct node *p = pHeader->pNext; /* 定义ｐ，指向第一个有效节点 */
struct node *pBack = NULL;
if((NULL == p) || (NULL == p->pNext))
return ;
while(NULL != p->pNext)
{
pBack = p->pNext; /* 将ｐ节点的后一个节点（目标节点）的pNext保存起来 */
p->pNext = pBack->pNext; /* 将ｐ节点和目标节点的后一个节点连接起来 */
pBack->pNext = pHeader->pNext; /* 将目标节点和ｐ节点链接起来 */
pHeader->pNext = pBack; /* 将目标节点和头节点链接起来 */
}
}
双链表的引入和基本实现
单链表的局限性
- 单链表是对数组的一个扩展，解决了数组的大小比较死板不容易扩展的问题。使用堆内存来存储数据，将数据分散到各个节点之间，其各个节点在内存中可以不相连，节点之间通过指针进行单向链接。链表中的各个节点内存不相连，有利于利用碎片化的内存。
- 单链表各个节点之间只由一个指针单向链接，这样实现有一些局限性。局限性主要体现在单链表只能经由指针单向移动（一旦指针移动过某个节点就无法再回来，如果要再次操作这个节点除非从头指针开始再次遍历一次），因此单链表的某些操作就比较麻烦（算法比较有局限）。回忆之前单链表的所有操作（插入、删除节点、 遍历、从单链表中取某个节点的数·····），因为单链表的单向移动性导致了不少麻烦。
- 总结：单链表的单向移动性导致我们在操作单链表时，当前节点只能向后移动不能向前移动，因此不自由，不利于解决更复杂的算法。
解决思路：有效数据+2个指针的节点（双链表）
- 单链表的节点 = 有效数据 + 指针（指针指向后一个节点）
- 双向链表的节点 = 有效数据 + 2个指针（一个指向后一个节点，另一个指向前一个节点）
双链表的封装和编程实现
struct bidi_node
{
struct bidi_node *pPrev; /* 前向指针，指向前一个节点 */
int data; /* 数据区 */
struct bidi_node *pNext; /* 后向指针，指向后一个节点 */
};
//创建一个双向链表节点
struct bidi_node *create_bidi_node(int data)
{
struct bidi_node *p = (struct bidi_node *)malloc(sizeof(struct bidi_node));
if(NULL == p)
{
printf("malloc *p error.
");
return NULL;
}
memset(p, ' ', sizeof(struct bidi_node));
p->pPrev = NULL;
p->data = data;
p->pNext = NULL;
return p;
}
双链表的算法之插入节点
尾部插入
/**
* 插入一个尾节点
* pHeader：指向一个头节点
* new_node：为插入的新节点
*/
void insert_node_tail(struct bidi_node *pHeader, struct bidi_node *new_node)
{
struct bidi_node *p = pHeader;
while(NULL != p->pNext) /* 第一步，在链表中找到最后一个节点 */
{
p = p->pNext;
}
/* 第二步：将新节点插入到原来的尾节点的后面 */
p->pNext = new_node; /* 后向指针关联好了。新节点的地址和前节点的next */
new_node->pPrev = p; /* 前向指针关联好了。新节点的prev和前节点的地址 */
}头部插入
/**
* 插入一个头节点
* pHeader：指向一个头节点
* new_node：为插入的新节点
*/
void insert_node_head(struct bidi_node *pHeader, struct bidi_node *new_node)
{
new_node->pNext = pHeader->pNext; /* 新节点的next指针指向原来的第1个有效节点的地址 */
if(NULL != pHeader->pNext)
pHeader->pNext->pPrev = new_node; /* 原来第1个有效节点的prev指针指向新节点的地址 */
pHeader->pNext = new_node; /* 头节点的next指针指向新节点地址 */
new_node->pPrev = pHeader; /* 新节点的prev指针指向头节点的地址 */
}
双链表的算法之遍历节点
- 双链表是单链表的一个父集。双链表中如何完全无视pPrev指针，则双链表就变成了单链表。这就决定了双链表的正向遍历（后向遍历）和单链表是完全相同的。
- 双链表中因为多了pPrev指针，因此双链表还可以前向遍历（从链表的尾节点向前面依次遍历直到头节点）。但是前向遍历的意义并不大，主要是因为很少有当前当了尾节点需要前向遍历的情况。
- 总结：双链表是对单链表的一种有成本的扩展，但是这个扩展在有些时候意义不大，在另一些时候意义就比较大。因此在实践用途中要根据业务要求选择适合的链表。
/*
* 双链表向后遍历节点
* pHeader：指向头节点
*/
void backward_ergodic(struct bidi_node *pHeader)
{
struct bidi_node *p = pHeader; /* 定义一个ｐ指针，指向头节点 */
if(NULL == p) /* 如果头节点不存在 */
{
return;
}
while(NULL != p->pNext) /* 循环遍历 */
{
p = p->pNext;
printf("data = %d.
", p->data);
}
}
/**
* 双链表向前遍历节点
* pTail：指向尾节点
*/
void forward_ergodic(struct bidi_node *pTail)
{
struct bidi_node *p = pTail;
if(NULL == p) /* 如果头节点不存在 */
{
return;
}
while(NULL != p->pPrev)
{
printf("data = %d.
", p->data);
p = p->pPrev;
}
}
双链表的算法之删除节点
/**
* 双链表之删除节点
* pHeader：指向头节点
* data：需要查找的数据
*/
void delete_node(struct bidi_node *pHeader, int data)
{
struct bidi_node *p = pHeader;
if(NULL == p) /* 如果头节点不存在 */
{
return;
}
while(NULL != p->pNext)
{
p = p->pNext;
if(p->data == data) /* 如果是尾节点 */
{
if(NULL == p->pNext)
{
p->pPrev->pNext = NULL;
}
else /* 如是普通节点 */
{
p->pPrev->pNext = p->pNext; /* 前一个节点的next指针指向后一个节点的首地址 */
/* 当前节点的prev和next指针都不用管，因为后面会整体销毁整个节点 */
p->pNext->pPrev = p->pPrev; /* 后一个节点的prev指针指向前一个节点的首地址 */
}
free(p);
return (void)0;
}
}
printf("未找到该节点.
");
}
linux内核链表
前述链表数据区域的局限性
- 之前定义数据区域时直接int data;我们认为我们的链表中需要存储的是一个int类型的数。但是实际上现实编程中链接中的节点不可能这么简单，而是多种多样的。
- 一般实际项目中的链表，节点中存储的数据其实是一个结构体，这个结构体中包含若干的成员，这些成员加起来构成了我们的节点数据区域。
一般性解决思路：数据区封装为一个结构体
- 因为链表实际解决的问题是多种多样的，所以内部数据区域的结构体构成也是多种多样的。这样也导致了不同程序当中的链表总体构成是多种多样的。导致的问题是：我们无法通过一个泛性的、普遍适用的操作函数来访问所有的链表。这就意味着我们设计一个链表就得写一套链表的操作函数（节点创建、插入、删除、遍历······）
- 实际上深层次分析会发现：不同的链表虽然这些方法不能通用需要单独写，但是实际上内部的思路和方法是相同的，只是函数的局部地区有不同。（实际上链表操作是相同的，而涉及到数据区域的操作就有不同）
- 鉴于以上2点：我们的理念就是，能不能有一种办法把所有链表中操作方法里共同的部分提取出来用一套标准方法实现，然后把不同的部分留着让具体链表的实现者自己去处理。
内核链表的设计思路
- 内核链表中自己实现了一个纯链表（纯链表就是没有数据区域，只有前后向指针）的封装，以及纯链表的各种操作函数（节点创建、插入、删除、遍历······）。这个纯链表本身自己没有任何用处，它的用法是给我们具体链表作为核心来调用。
list.h文件简介
- (1)内核中核心纯链表的实现在include/linux/list.h文件中
- (2)list.h中就是一个纯链表的完整封装，包含节点定义和各种链表操作方法。
内核链表的基本算法和使用简介
内核链表的节点创建、删除、遍历等
内核链表的使用实践
- 问题：内核链表只有纯链表，没有数据区域，怎么使用？
- 设计的使用方法是将内核链表作为将来整个数据结构的结构体的一个成员内嵌进去。
什么是状态机
有限状态机
- 常说的状态机是有限状态机FSM。FSM指的是有有限个状态（一般是一个状态变量的值），这个机器同时能够从外部接收信号和信息输入，机器在接收到外部输入的信号后会综合考虑当前自己的状态和用户输入的信息，然后机器做出动作：跳转到另一个状态。
- 考虑状态机的关键点：当前状态、外部输入、下一个状态
两种状态机：Moore型和Mealy型
- Moore型状态机特点是：输出只与当前状态有关（与输入信号无关）。相对简单，考虑状态机的下一个状态时只需要考虑它的当前状态就行了。
- Mealy型状态机的特点是：输出不只和当前状态有关，还与输入信号有关。状态机接收到一个输入信号需要跳转到下一个状态时，状态机综合考虑2个条件（当前状态、输入值）后才决定跳转到哪个状态。
状态机的主要用途：电路设计、FPGA程序设计、软件设计
- 电路设计中广泛使用了状态机思想
- FPGA程序设计
- 软件设计（框架类型的设计，譬如操作系统的GUI系统、消息机制）
状态机解决了什么问题
- 我们平时写程序都是顺序执行的，这种程序有个特点：程序的大体执行流程是既定的，程序的执行是遵照一定的大的方向有迹可寻的。
- 但是偶尔会碰到这样的程序：外部不一定会按照既定流程来给程序输入信息，而程序还需要完全能够接收并响应外部的这些输入信号，还要能做出符合逻辑的输出。
C语言实现简单的状态机
- 题目：开锁状态机。功能描述：用户连续输入正确的密码则会开锁，如果密码输入过程错误则锁会退回到初始状态重新计入密码，即：用户只需要连续输入出正确的密码即可开锁（输入错误不用撤销、也不用删除）
题目分析
多线程简介
操作系统下的并行执行机制
- 并行就是说多个任务同时被执行。并行分宏观上的并行和微观上的并行。
- 宏观上的并行就是从长时间段（相对于人来说）来看，多个任务是同时进行的；微观上的并行就是真的在并行执行。
- 操作系统要求实现宏观上的并行。宏观上的并行有2种情况：第一种是微观上的串行，第二种是微观上的并行。
- 理论来说，单核CPU本身只有一个核心，同时只能执行一条指令，这种CPU只能实现宏观上的并行，微观上一定是串行的。微观上的并行要求多核心CPU。多核CPU中的多个核心可以同时微观上执行多个指令，因此可以达到微观上的并行，从而提升宏观上的并行度。
进程和线程的区别和联系
- 进程和线程是操作系统的两种不同软件技术，目的是实现宏观上的并行（通俗一点就是让多个程序同时在一个机器上运行，达到宏观上看起来并行执行的效果）。
- 进程和线程在实现并行效果的原理上不同。而且这个差异和操作系统有关。譬如windows中进程和线程差异比较大，在linux中进程和线程差异不大（linux中线程就是轻量级的进程）。
- 不管是多进程还是多线程，最终目标都是实现并行执行。
多线程的优势
- 前些年多进程多一些，近些年多线程开始用得多。
- 现代操作系统设计时考虑到了多核心CPU的优化问题，保证了：多线程程序在运行的时候，操作系统会优先将多个线程放在多个核心中分别单独运行。所以说多核心CPU给多线程程序提供了完美的运行环境。所以在多核心CPU上使用多线程程序有极大的好处。
线程同步和锁
- 多线程程序运行时要注意线程之间的同步。