由于上一节最后的桶排序和基数排序都需要用到链表，所以这一节先补补链表，栈。队列。哈希表的知识。
3.1 链表
3.1.1 单链表
链表感觉都没什么好说的，是嵌入式使用的比较多的一种数据结构，但是也要基本介绍介绍，下面是单向链表的结构：参考《漫画算法》
链表是一种在内存中非连续，非顺序的数据结构，由若干节点所组成。单链表看到图发现由两部分组成，一部分是存放数据的变量data，一部分是存放指向下一个节点的指针next。
typedef struct single_link
{
int data; //数据区域
struct single_link *next; //指向下一个节点
}_single_link_T;
为了方便操作，我们都会把链表的第一个节点称为头节点，头节点的data值一般没意义，不过通常习惯保存这个链表的长度，最后一个节点称为尾节点，尾节点的指针指向NULL，每次遍历的时候都是判断next指针是否为NULL来判断节点是不是结束。
从图也可以看到，链表是通过next指针指向下一个，下一个的next又指向下一个。
3.1.2 双链表
单链表中有一个不好的地方就是查找上一个的时候，不方便，所以这时候引入了双向链表，双向链表的意思就是在链表节点中又添加了一个指向上一个的指针，名字为prev指针。双链表的结构：
由图可以看出两个指针next、prev分别指向下一个和上一个
//双链表结构体
typedef struct double_link
{
int data; //数据区域
struct double_link *prev; //指向上一个节点
struct double_link *next; //指向下一个节点
}_double_link_T;
使用一个数据结构，简单的方法就是增、删、改、查
3.1.3 链表的基本操作
- 增
链表的增，有两种方式，一个是尾插法，一种是头插法。
单链表的增加操作，看图：
尾插法：
第一步先遍历链表，找到最后一个节点之后，把最后一个节点的next指针赋值给新节点的next，也就是新节点的next指向了NULL，然后最后一个节点的next指向新节点。这样就插入成功，代码如下：
/**
* @brief 单链表尾部添加
* @param
* @retval
*/
int single_link_tail_add(struct single_link *link, Elemtype item)
{
//申请一个新节点
struct single_link *node = NULL;
node = (struct single_link *)malloc(sizeof(struct single_link));
if(node == NULL)
return -1;
node->data = item; //填充数据
//遍历数据，找到尾节点
struct single_link * pNext = link;
while(pNext->next != NULL) //不等于空继续循环
{
pNext = pNext->next;
}
//现在执行插入操作
node->next = pNext->next;
pNext->next = node;
link->data++;
return 0;
}
头插法：
头插法其实跟尾插法逻辑差不多，只不过尾插法是要遍历到链表尾部，头插法就用头节点即可。
代码如下：
/**
* @brief 单链表头部添加
* @param
* @retval
*/
int single_link_head_add(struct single_link *link, Elemtype item)
{
//申请一个新节点
struct single_link *node = NULL;
node = (struct single_link *)malloc(sizeof(struct single_link));
if(node == NULL)
return -1;
node->data = item; //填充数据
//头节点
struct single_link * pNext = link;
//现在执行插入操作
node->next = pNext->next;
pNext->next = node;
link->data++;
return 0;
}
双链表以后有需要再增加，哈哈哈
- 删
删除操作一般都是传入一个值，判断这个值的节点的位置，然后进行删除。
查询这个节点，直接看查了，这里直接讲删除，因为我们是用单链表，所以前一个节点的指针不能丢，丢了就就找不到了。
/**
* @brief 删除一个节点
* @param
* @retval
*/
int single_link_remove(struct single_link *link, Elemtype item)
{
if(link == NULL)
return -1;
//遍历数据
struct single_link * pNext = link;
struct single_link * node = NULL;
while(pNext->next != NULL) //不等于空继续循环
{
//判断next，是预先判断下一个值，是不是需要删除的
if(pNext->next->data == item)
break;
pNext = pNext->next;
}
//这个是拿到上一个节点的指针，所以要删除的节点是下一个
node = pNext->next;
//这个就是把下一个下一个指针赋值给现在的next
pNext->next = pNext->next->next;
link->data--;
free(node);
return 0;
}
-
改
以后再写，就是查询到对应的位置，然后修改值。 -
查
以后再写，现在都不知道使用在啥场景。 -
释放链表
这里写基数排序的时候，就搞错了，调了半天才调出来，看来链表操作还是需要画图
。释放链表其实跟上面的删除差不多，只不过是循环删除。
/**
* @brief 删除链表，只剩下头节点
* @param
* @retval
*/
int single_link_delete(struct single_link *link)
{
if(link == NULL)
return -1;
//遍历数据
struct single_link * pNext = link;
struct single_link * node = NULL;
//判断下一个不为空，就进入删除
while(pNext->next != NULL) //不等于空继续循环
{
//删除的逻辑跟删除一个差不多
node = pNext->next;
pNext->next = pNext->next->next;
link->data--;
free(node);
}
return 0;
}
3.1.4 循环链表
循环链表这里没什么可说的，就是尾指针不指向NULL，指向了头节点，就是这么简单。单双链表都可以循环。
3.1.5 附加：链表的面试题
1.单链表逆序
面试题比较喜欢出单链表逆序，可能一个单链表只有一个指针，逆序比较难把，所以经常考，浏览了一下别人的博客，这两篇写的还可以，可以参考参考。
https://blog.csdn.net/qq_39871576/article/details/80613365
https://blog.csdn.net/qq_33160790/article/details/54948745
不查不知道，一查吓一跳，然后单链表逆序有3种解法，
- 普通循环
当然去面试就是用这种普通循环，确实有点难受，没有系统学习过的，就是吃亏，今天在这里补救补救。
普通循环方法比较难受的就是逻辑处理，不过相通了之后就清楚了，为了协助理解还是需要画图：
(1) 原链表：
(2) 链表逆序，只要是把next指针指向前面的data，每次调转一个指针，依次循环，下面按步骤进行：
这里要准备3个指针，pPrev指向前一个节点的指针，pCur指向当前节点的指针，pNext指向后一个节点的指针，所以要把pPrev赋值给pCur->next，因为刚开始pPrev是头节点，所以把pPrev设为NULL，所以pCur->next=NULL;然后把3个指针右移，这里要注意一个链表头节点next指针还指向data1
(3) 继续逆序
操作方式跟上一步一样
(4) 继续
操作步骤跟上面一样
（5）处理头节点
之前操作为了统一，没有对头节点做处理，现在操作完成了，把头节点的next指针指向左后一个节点，然后现在就形成了一条链表，导致逆序成功。下面是把其他东西删除后的结果
代码如下：
/**
* @brief 单链表逆序，普通循环法
* @param
* @retval
*/
int single_link_reverse1(struct single_link *link)
{
if(link == NULL)
return -1;
//获取3个指针，前节点指针，当前节点指针，后节点指针
struct single_link *pPrev, *pCur, *pNext;
//调转指针
pPrev = NULL; //默认开始为NULL，把头节点断开
pCur = link->next;
while(pCur != NULL) //判断当前指针不为空
{
pNext = pCur->next; //保存后节点指针
pCur->next = pPrev; //pCur->next指向头节点
pPrev = pCur; //前节点指针右移
pCur = pNext; //当前节点指针右移
}
//处理头节点,把最后一个节点挂接在头节点next指针
link->next = pPrev;
printf("pPrev %p %p %p %p\n", pPrev, pPrev->next, pPrev->next->next, pPrev->next->next->next);
return 0;
}
- 头插法
- 递归
2.判断单链表是否有环
参考《漫画算法》
准备两个指针，一个指针一次后移一个节点，一个指针一次后移两个节点，如果相遇说明链表有环，这相当于两个运动员在操场跑步，快的运动员总会追上慢的运动员，这就是判断链表是否有环。
上面就是两个指针移动的示意图，如果链表有环就一定会相遇
下面时实现代码：
/**
* @brief 判断单链表是否有环
* @param
* @retval =1表示链表有环，=0表示链表没环
* @idea 准备两个指针，一个指针一次后移一个节点，一个指针一次后移两个节点，
如果相遇说明链表有环，快的指针会碰到或者超越慢的指针
*/
int single_link_isCycle(struct single_link *link)
{
if(link == NULL)
return -1;
//1.申请2个指针
struct single_link *p1 = link;
struct single_link *p2 = link;
//2.开始遍历链表，查询是否有环
while(p1 && p1->next)
{
p1 = p1->next->next; //一次后移两个节点
p2 = p2->next; //一次后移一个节点
if(p1 == p2)
return 1;
}
return 0;
}
扩展问题：
（1）如果链表有环，环的长度：
当两个指针首次想遇，证明链表有环的时候，让两个指针从相遇点继续循环前进，并统计前进的循环次数，直到两个指针第2次相遇，此时，统计出来的前进次数就是环长。
因为指针p1每次走1步，指针p2每次走2步，两者的速度差1步，当两个指针再次相遇时，p2比p1多走了整整1圈。因此，环长=每一次速度差X前进次数=前进次数。
来自《漫画算法》
简单代码如下：
/**
* @brief 单链表的环长
* @param
* @retval 环的长度
*/
int single_link_cycle_len(struct single_link *link)
{
if(link == NULL)
return -1;
//1.申请2个指针
struct single_link *p1 = link;
struct single_link *p2 = link;
int cycle_len = 0, flag = 0;
//2.开始遍历链表，查询是否有环
while(p1 && p1->next)
{
p1 = p1->next->next; //一次后移两个节点
p2 = p2->next; //一次后移一个节点
if((p1 == p2) || flag)
{
if(p1 == p2 && flag)
break;
(flag) ? (cycle_len++):(flag=1);
}
}
printf("cycle_len = %d\n", cycle_len);
return cycle_len;
}
（2）如果链表有环，求入环点（来自《漫画算法》）
上图是对有环链表所做的一个抽象示意图。假设从链表头节点到入环点的距离是D，从入环点到两个指针首次相遇点的距离为S1,从首次相遇点回到入环点的距离是S2。
那么，当两个指针首次相遇时，各自所走的距离是多少呢？
指针p1一次只走1步，所走的距离是D+S1。
指针p2一次走2步，多走了1整圈，所走的距离是D+S1+S2+S1=D+2S1+S2。
由于p2的速度是p1的2倍，所以所走距离也是p1的2倍，因此
2(D+S1) =D+2S1+S2
等式经过整理得出：
D=S2
也就是说，从链表头节点到入环点的距离，等于从首次相遇点回到入环点的距离。
这样一来，只要把其中一个指针放回到头节点位置，另一个指针保持在首次相遇点，两个指针都是每次向前走1步。那么，它们最终相遇的节点，就是入环节点。
代码如下：
/**
* @brief 单链表入环点
* @param
* @retval 入环点
*/
int single_link_cycle_point(struct single_link *link)
{
if(link == NULL)
return -1;
//1.申请2个指针
struct single_link *p1 = link;
struct single_link *p2 = link;
struct single_link *p3 = link;
//2.开始遍历链表，查询是否有环
while(p1 && p1->next)
{
p1 = p1->next->next; //一次后移两个节点
p2 = p2->next; //一次后移一个节点
if(p1 == p2)
{
break;
}
}
//3.再由一个指针从头节点开始后移，p2指针继续后移两个指针相遇时，就是入环点
while(p2 && p3)
{
p2 = p2->next;
p3 = p3->next;
if(p2 == p3)
break;
}
printf("cycle_len = %d\n", p2->data);
return p2->data;
}
3.合并两条单链表
以后再搞
