1、链表优点
相比较普通的线性结构，链表结构的优势是什么呢？我们可以总结一下：
（1）单个节点创建非常方便，普通的线性内存通常在创建的时候就需要设定数据的大小
（2）节点的删除非常方便，不需要像线性结构那样移动剩下的数据
（3）节点的访问方便，可以通过循环或者递归的方法访问到任意数据，但是平均的访问效率低于线性表
那么在实际应用中，链表是怎么设计的呢？我们可以以int数据类型作为基础，设计一个简单的int链表：
2、单向链表
（1）设计链表的数据结构
typedef struct _LINK_NODE
{
int data;//数据域
struct _LINK_NODE* next;//指针域
}LINK_NODE;
（2）创建链表
LINK_NODE* alloca_node(int value)//创建链表，分配大小，并赋值
{
LINK_NODE* pLinkNode = NULL;
pLinkNode = (LINK_NODE*)malloc(sizeof(LINK_NODE));
pLinkNode->data = value;
pLinkNode->next = NULL;
return pLinkNode;
}（3）删除链表
void delete_node(LINK_NODE** pNode)
{
LINK_NODE** pNext;
if(NULL == pNode || NULL == *pNode)
return ;
pNext = &(*pNode)->next;//链表下一个结点保存下来
free(*pNode);//释放掉
*pNode = NULL; //释放后，加NULL
delete_node(pNext); //遍历下一个结点，不断迭代
}（4）链表插入数据
STATUS _add_data(LINK_NODE** pNode, LINK_NODE* pDataNode)
{
if(NULL == *pNode){ //尾结点
*pNode = pDataNode;
return TRUE;
}
return _add_data(&(*pNode)->next, pDataNode);
}
STATUS add_data(const LINK_NODE** pNode, int value)
{
LINK_NODE* pDataNode;
if(NULL == *pNode)
return FALSE;
pDataNode = alloca_node(value);//分配大小
assert(NULL != pDataNode);
return _add_data((LINK_NODE**)pNode, pDataNode);
}（5）链表删除数据
STATUS _delete_data(LINK_NODE** pNode, int value)
{
LINK_NODE* pLinkNode;
if(NULL == (*pNode)->next)
return FALSE;
pLinkNode = &(*pNode)->next;
if(value == pLinkNode->data){
(*pNode)->next = pLinkNode->next;//保存下来
free(pLinkNode);
pLinkNode = NULL;
return TRUE;
}else{
return _delete_data(&(*pNode)->next, value);//继续遍历
}
}
STATUS delete_data(LINK_NODE** pNode, int value)
{
LINK_NODE* pLinkNode;
if(NULL == pNode || NULL == *pNode)
return FALSE;
if(value == (*pNode)->data){ //
pLinkNode = *pNode;
*pNode = pLinkNode->next;//保存下来
free(pLinkNode);
pLinkNode = NULL;
return TRUE;
}
return _delete_data(pNode, value);
}（6）链表查找数据
LINK_NODE* find_data(const LINK_NODE* pLinkNode, int value)
{
if(NULL == pLinkNode)
return NULL;
if(value == pLinkNode->data)
return (LINK_NODE*)pLinkNode;
return find_data(pLinkNode->next, value);
}（7）打印链表数据
void print_node(const LINK_NODE* pLinkNode)
{
if(pLinkNode){
printf("%d\n", pLinkNode->data);
print_node(pLinkNode->next);
}
}（8）统计数据
int count_node(const LINK_NODE* pLinkNode)
{
if(NULL == pLinkNode)
return 0;
return 1 + count_node(pLinkNode->next);
}3、单循环链表
单链表是指最后一个节点的指针是空指针，我们将终端结点指针端由空指针指向头结点，就使整个链表形成一个环，这种头尾相接的单链表就成为单循环链表。
（1）打印链表数据
void print_data(const LINK_NODE* pLinkNode)
{
LINK_NODE* pIndex = NULL;
if(NULL == pLinkNode)//空链表
return;
printf("%d\n", pLinkNode->data);
pIndex = pLinkNode->next;
while(pLinkNode != pIndex){ //尾结点后面一个结点是不是头结点
printf("%d\n", pIndex->data);
pIndex = pIndex ->next;
}
}以往，我们发现打印数据的结束都是判断指针是否为NULL，这里因为是循环链表所以发生了变化。原来的条件（NULL != pLinkNode）也修改成了这里的（pLinkNode != pIndex）。同样需要修改的函数还有find函数、count统计函数。
（2）链表插入数据
STATUS insert_data(LINK_NODE** ppLinkNode, int data)
{
LINK_NODE* pNode;
if(NULL == ppLinkNode)
return FALSE;
if(NULL == *ppLinkNode){
pNode = create_link_node(data);
assert(NULL != pNode);
pNode->next = pNode;
*ppLinkNode = pNode;
return TRUE;
}
if(NULL != find_data(*ppLinkNode, data))
return FALSE;
pNode = create_link_node(data);
assert(NULL != pNode);
pNode->next = (*ppLinkNode)->next;
(*ppLinkNode)->next = pNode;
return TRUE;
}这里的insert函数在两个地方发生了变化：
a）如果原来链表中没有节点，那么链表节点需要自己指向自己
b）如果链表节点原来存在，那么只需要在当前的链表节点后面添加一个数据，同时修改两个方向的指针即可
（3） 删除数据
STATUS delete_data(LINK_NODE** ppLinkNode, int data)
{
LINK_NODE* pIndex = NULL;
LINK_NODE* prev = NULL;
if(NULL == ppLinkNode || NULL == *ppLinkNode)
return FALSE;
pIndex = find_data(*ppLinkNode, data);
if(NULL == pIndex)
return FALSE;
if(pIndex == *ppLinkNode){
if(pIndex == pIndex->next){
*ppLinkNode = NULL;
}else{
prev = pIndex->next;
while(pIndex != prev->next)
prev = prev->next;
prev->next = pIndex->next;
*ppLinkNode = pIndex->next;
}
}else{
prev = pIndex->next;
while(pIndex != prev->next)
prev = prev->next;
prev->next = pIndex->next;
}
free(pIndex);
return TRUE;
}和添加数据一样，删除数据也要在两个方面做出改变：
a）如果当前链表节点中只剩下一个数据的时候，删除后需要设置为NULL
b）删除数据的时候首先需要当前数据的前一个数据，这个时候就可以从当前删除的数据开始进行遍历
c） 删除的时候需要重点判断删除的数据是不是链表的头结点数据
分析：上面我们介绍了单向链表。下面我们介绍双向链表，顾名思义，就是数据本身具备了左边和右边的双向指针。双向链表相比较单向链表，主要有下面几个特点：
（1）在数据结构中具有双向指针
（2）插入数据的时候需要考虑前后的方向的操作
（3）同样，删除数据的是有也需要考虑前后方向的操作
那么，一个非循环的双向链表操作应该是怎么样的呢？我们可以自己尝试一下：
4、双向链表
（1）定义双向链表的基本结构
typedef struct _DOUBLE_LINK_NODE
{
int data;
struct _DOUBLE_LINK_NODE* prev;
struct _DOUBLE_LINK_NODE* next;
}DOUBLE_LINK_NODE;（2）创建双向链表节点
DOUBLE_LINK_NODE* create_double_link_node(int value)
{
DOUBLE_LINK_NODE* pDLinkNode = NULL;
pDLinkNode = (DOUBLE_LINK_NODE*)malloc(sizeof(DOUBLE_LINK_NODE));
assert(NULL != pDLinkNode);
memset(pDLinkNode, 0, sizeof(DOUBLE_LINK_NODE));
pDLinkNode->data = value;
return pDLinkNode;
}（3）删除双向链表
void delete_all_double_link_node(DOUBLE_LINK_NODE** pDLinkNode)
{
DOUBLE_LINK_NODE* pNode;
if(NULL == *pDLinkNode)
return ;
pNode = *pDLinkNode;
*pDLinkNode = pNode->next;
free(pNode);
delete_all_double_link_node(pDLinkNode);
}
（4）在双向链表中查找数据
DOUBLE_LINK_NODE* find_data_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode, int data)
{
DOUBLE_LINK_NODE* pNode = NULL;
if(NULL == pDLinkNode)
return NULL;
pNode = (DOUBLE_LINK_NODE*)pDLinkNode;
while(NULL != pNode){
if(data == pNode->data)
return pNode;
pNode = pNode ->next;
}
return NULL;
}（5）双向链表中插入数据
STATUS insert_data_into_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)
{
DOUBLE_LINK_NODE* pNode;
DOUBLE_LINK_NODE* pIndex;
if(NULL == ppDLinkNode)
return FALSE;
if(NULL == *ppDLinkNode){
pNode = create_double_link_node(data);
assert(NULL != pNode);
*ppDLinkNode = pNode;
(*ppDLinkNode)->prev = (*ppDLinkNode)->next = NULL;
return TRUE;
}
if(NULL != find_data_in_double_link(*ppDLinkNode, data))
return FALSE;
pNode = create_double_link_node(data);
assert(NULL != pNode);
pIndex = *ppDLinkNode;
while(NULL != pIndex->next)
pIndex = pIndex->next;
pNode->prev = pIndex;
pNode->next = pIndex->next;
pIndex->next = pNode;
return TRUE;
}（6）双向链表中删除数据
STATUS delete_data_from_double_link(DOUBLE_LINK_NODE** ppDLinkNode, int data)
{
DOUBLE_LINK_NODE* pNode;
if(NULL == ppDLinkNode || NULL == *ppDLinkNode)
return FALSE;
pNode = find_data_in_double_link(*ppDLinkNode, data);
if(NULL == pNode)
return FALSE;
if(pNode == *ppDLinkNode){
if(NULL == (*ppDLinkNode)->next){
*ppDLinkNode = NULL;
}else{
*ppDLinkNode = pNode->next;
(*ppDLinkNode)->prev = NULL;
}
}else{
if(pNode->next)
pNode->next->prev = pNode->prev;
pNode->prev->next = pNode->next;
}
free(pNode);
return TRUE;
}（7）统计双向链表中数据的个数
int count_number_in_double_link(const DOUBLE_LINK_NODE* pDLinkNode)
{
int count = 0;
DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;
while(NULL != pNode){
count ++;
pNode = pNode->next;
}
return count;
}（8）打印双向链表中数据
void print_double_link_node(const DOUBLE_LINK_NODE* pDLinkNode)
{
DOUBLE_LINK_NODE* pNode = (DOUBLE_LINK_NODE*)pDLinkNode;
while(NULL != pNode){
printf("%d\n", pNode->data);
pNode = pNode ->next;
}
}时间： 2024-08-06 19:50:18