链表的概念
1.从上图可以看出链表的结构在逻辑上时连续的，在物理上是非连续的。
2.现实中的结点一般都是从堆上申请出来的。
3.从堆上申请的空间有一定的规则，两次申请的空间可能是连续的，也可能是非连续的。
链表的分类
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
2. 带头或者不带头
3. 循环或者非循环
虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：
1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的
子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
链表的实现 （无头单向非循环）
结点类型声明：
typedef int SLTDateType;
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SListNode;动态申请一个结点
malloc申请空间，将数据存入，下个结点的指针指向空即可；
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
if (newnode == NULL)
{
perror("malloc");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
return newnode;
}
单链表打印
访问完一个结点后用结点中next下个结点的指针找到下个结点依次访问即可；
// 单链表打印
void SListPrint(SListNode* plist)
{
assert(plist);
SListNode* phead = plist;
while (phead)
{
printf("%d->", phead->data);
phead = phead->next;
}
printf("NULL");
return;
}单链表尾插
！！！单链表的尾插在单链表本身为空的时候，会对传入的结构体的指针本身进行赋值，而函数中的指针只是对原指针的临时拷贝，因此要传入结构体的二级指针。
首先动态开辟一个结点。若链表本身为空，则将开辟的结点的指针赋给链表的头结点指针；若链表不为空，则进行找尾，将开辟的结点指针与尾结点的next连接起来；
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
assert(pplist);
SListNode* newnode = BuySListNode(x);
//链表本身为空：
if ((*pplist) == NULL)
{
*pplist = newnode;
}
//不为空；
//找尾；
else
{
SListNode* tail = *pplist;
while (tail->next != NULL)
{
tail = tail->next;
}
//插入；
tail->next = newnode;
}
}单链表的头插
！！！头插操作要对所给结构体指针进行赋值，因此要传入结构体的二级指针；
动态开辟一个结点newnode，newnode的next指向原先链表的头结点指针，newnode作为新的链表的头结点。
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
SListNode* newnode = BuySListNode(x);
newnode->next = *pplist;
*pplist = newnode;
}单链表的尾删
！！！尾删操作可能要对所给结构体指针进行赋值，因此要传入结构体的二级指针；
若只有一个结点释放结点空间，然后将链表的头结点指针置为空，若结点更多，则找尾结点的前一个结点，释放它的next(即尾结点的空间)，再将next置为NULL；
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
assert(pplist);
//不能为空的链表；
assert(*pplist != NULL);
//1个结点；
if ((*pplist)->next == NULL)
{
free(*pplist);
*pplist = NULL;
}
//两个或者两个以上；
//找尾的前一个；
SListNode* tail = *pplist;
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}单链表头删
注意事项与上面几个同样。
储存头结点下个结点的指针，释放头结点的空间，下个结点成为新的头结点；
// 单链表头删
void SListPopFront(SListNode** pplist)
{
assert(pplist);
//链表不能没有结点；
assert(*pplist);
//储存头结点下个结点的指针；
SListNode* cur = (*pplist)->next;
//释放头结点的空间；
free(*pplist);
//头结点变为下个结点。
*pplist = cur;
}单链表查找
遍历链表进行查找即可；
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
assert(plist);
SListNode* pos = plist;
while (pos)
{
if (pos->data == x)
{
return pos;
}
pos = pos->next;
}
return NULL;
}单链表在pos位置之后插入x
创建结点，然后插入到pos的后面即可；
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
assert(pos);
SListNode* newnode=BuySListNode(x);
newnode->next = pos->next;
pos->next = newnode;
}单链表删除pos位置之后的值
释放空间后，再与后面的结点连接起来即可；
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
assert(pos);
//pos的下个结点不为空；
assert(pos->next != NULL);
//记录下pos下个结点的下个结点的指针；防止释放下个结点的空间后找不到；
SListNode* cur = pos->next->next;
free(pos->next);
pos->next = cur;
}
单链表的销毁
记录下头结点的位置，头节点变为下个结点，释放头节点前一个结点的空间。
// 单链表的销毁
void SListDestroy(SListNode* plist)
{
assert(plist);
while (plist)
{
//记录下头结点的位置；
SListNode* cur = plist;
//头节点变为下个结点；
plist = plist->next;
//释放头节点前一个结点的空间；
free(cur);
}
plist = NULL;
}链表的实现（双向带头链表的实现）
类型结点声明：
typedef int listdate;
typedef struct listnode
{
struct listnode* prev;
struct listnode* next;
listdate date;
}listnode;里面包含一个数据，前后两个指针；
创建返回链表的头结点.
开辟一个头结点的空间，然后使它的首位都指向自己即可；
listnode* ListCreate()
{
listnode* head = (listnode*)malloc(sizeof(listnode));
if (head == NULL)
{
perror("malloc");
exit(-1);
}
head->next = head;
head->prev = head;
return head;
}创建链表的非头节点；
开辟一个结点的空间，存入数值即可；
listnode* newnodeCreate(listdate x)
{
listnode* newnode = (listnode*)malloc(sizeof(listnode));
if (newnode == NULL)
{
perror("malloc");
exit(-1);
}
newnode->date = x;
return newnode;
}双向链表打印
遍历一遍链表打印，因为头结点不储存数据，因此从头结点的下个结点打印即可；因为此时链表的首位是相连的，只要等链表遍历回到头结点的位置停止即可；
void ListPrint(listnode* pHead)
{
assert(pHead);
printf("head");
listnode* cur = pHead->next;
while (cur != pHead)
{
printf("<-%d->", cur->date);
cur = cur->next;
}
}双向链表的尾插；
首先动态开辟一个结点，再找到尾结点，然后连接起来，作为新的尾结点，然后使新的尾结点与头结点连接起开即可；
void ListPushBack(listnode* pHead, listdate x)
{
assert(pHead);
listnode* newnode = newnodeCreate(x);
//找尾；
listnode* tail = pHead->prev;
tail->next = newnode;
newnode->prev = tail;
newnode->next = pHead;
pHead->prev = newnode;
}双向链表的尾删；
首先找到尾结点，再找到尾结点的前一个结点作为新的尾结点，释放尾结点的空间，将新的尾结点与头结点连接起来；
void ListPopBack(listnode* pHead)
{
assert(pHead);
//找尾；
listnode* tail = pHead->prev;
//找尾的前一个结点；
listnode* prevtail = tail->prev;
//释放尾结点；
free(tail);
//连接新的尾结点与头结点；
prevtail->next = pHead;
pHead->prev = prevtail;
}双向链表的头增；
首先创建空间，然后连接新的结点与头结点后的下一个结点，最后新的结点与头结点连接起来即可；
void ListPushFront(listnode* pHead, listdate x)
{
assert(pHead);
//创建空间；
listnode* newnode = newnodeCreate(x);
//新的结点与头结点后的下一个结点连接；
newnode->next = pHead->next;
pHead->next->prev = newnode;
//新的结点与头结点连接起来；
pHead->next = newnode;
newnode->prev = pHead;
}双向链表的头删；
首先找到头结点后的第二个结点，再释放头结点后的第一个结点，最后连接头结点与头结点后的第二个结点；
void ListPopFront(listnode* pHead)
{
assert(pHead);
//找到头结点后的第二个结点；
listnode* headnext = pHead->next->next;
//释放头结点后的第一个结点；
free(pHead->next);
//连接头结点与头结点后的第二个结点
pHead->next = headnext;
headnext->prev = pHead;
}双向链表的查找；
遍历一遍链表查找即可，与打印的过程基本类似；
listnode* ListFind(listnode* pHead, listdate x)
{
assert(pHead);
listnode* cur = pHead->next;
while (cur != pHead)
{
if (cur->date == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}双向链表在pos的前面进行插入
首先创建结点的空间，再找到pos的前一个结点，然后将pos与新的结点连接起来，最后将pos的前一个结点与新结点连接起来；
void ListInsert(listnode* pos, listdate x)
{
assert(pos);
//创建空间；
listnode* newnode = newnodeCreate(x);
//找到pos的前一个结点；
listnode* posprev = pos->prev;
//将pos与新的结点连接起来；
newnode->next = pos;
pos->prev = newnode;
//将pos的前一个结点与新结点连接起来；
posprev->next = newnode;
newnode->prev = posprev;
}双向链表删除pos位置的结点
连接pos的首尾，再释放pos即可；
void ListErase(listnode* pos)
{
assert(pos);
//连接pos的首尾
pos->prev->next = pos->next;
pos->next->prev = pos->prev;
free(pos);
}顺序表和链表的区别
我们用两幅图来总结它们之间的区别；
2234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
