线性表链式存储的特点是:用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的)。
因此,为了表示每个数据元素a(i)与其直接后继数据元素a(i+1)之间的逻辑关系,对于数据元素a(i)来说,除了存储其本身的信息之外,还需要存储一个指示其直接后继的信息(直接后继存储位置)。这两部分组成信息组成元素a(i)的存储映像,称为节点(node)。
它包括两个域:其中存储数据元素信息的域称为数据域;存储直接后继存储位置的域称为指针域。
指针域中的存储信息称为指针或链。
链表节点的逻辑结构:
线性表的链式表示与实现
1. 链表的概念及结构
概念:链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
举个栗子:
链表的结构就像火车的结构是一节一节的。不同于火车的是,链表它在物理存储结构上不是连续存储的,而是通过指针链接次序实现的 。
单链表的逻辑结构:
2.链表的分类
实际中链表的结构非常多样,以下情况组合起来就有8种链表结构:
- 单向或者双向
- 带头或者不带头
- 循环或者非循环
以上3大类可以组合成:
(1)不带头单向不循环链表
(2)不带头双向不循环链表
(3)不带头单向循环链表
(4)不带头双向循环链表
(5)带头单向不循环链表
(6)带头双向不循环链表
(7)带头单向循环链表
(8)带头双向循环链表
虽然有这么多的链表的结构,但是我们实际中最常用还是两种结构:
2.1 无头单向非循环链表
无头单向非循环链表:结构简单,一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2.2 带头双向循环链表
带头双向循环链表:结构最复杂,一般用在单独存储数据。实际中使用的链表数据结构,都是带头双向循环链表。另外这个结构虽然结构复杂,但是使用代码实现以后会发现结构会带来很多优势,实现反而简单了,后面我们代码实现了就知道了。
3.无头单向非循环链表的实现
3.1 链表需要实现的接口
// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SListNode;
// 动态申请一个结点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
//创建单链表
SListNode* CreateSListNode(SLTDateType x);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(const SListNode* pplist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
//单链表的销毁
void SListDestroy(SListNode* plist);
3.2 链表接口的具体实现
3.2.1 动态申请一个结点
SListNode* BuySListNode(SLTDateType x);
【算法步骤】
1.动态开辟一个新的节点。用指针newnode指向开辟的节点。
2.判断内存开辟是否成功,不成功的话,则结束程序。
3.新节点的数据域赋值为x。
4.新节点的指针域置NULL。
5.返回新节点的地址。
【算法实现】
SListNode* BuySListNode(SLTDateType x)
{
SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
if (!newnode)
{
perror("malloc fail\n");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
return newnode;
}
3.2.2 单链表的打印
void SListPrint(SListNode* plist);
【算法步骤】
1.判断头结点的地址是否为空,为空的的话,程序停止,这里我选择的是暴力的处理方式,当然你也可以选择温柔的方式,打印错误的原因,不直接停止程序。
2.定义一个指针cur,让他向后遍历。
3.如果指针cur不为空,就打印该节点的数据域。
4.指针cur再指向下一个节点,直到指针cur为空。
【算法实现】
void SListPrint(SListNode* plist)
{
assert(plist);
SListNode* cur = plist;
while (cur)
{
printf("%d->", cur->data);
cur = cur->next;
}
printf("NULL\n");
}
3.2.3 创建单链表
SListNode* CreateSListNode(SLTDateType x);
【算法步骤】
1.创建两个指针phead和指针ptail,指针phead用于指向创建的链表的头结点,指针ptail用于指向新建链表的尾节点。
2.循环生成n个节点。需要注意的是,第一次生成节点时,要将新建的节点地址赋给指针phead,不然当整个链表创建完的时候,就找不到头结点了,造成内存泄露,并且,没有完成我们需要的功能。
3.链表创建完成,将头结点的地址返回。
【算法实现】
SListNode* CreateSListNode(int n)
{
SListNode* phead = NULL,*ptail = NULL;
for (int i = 0;i < n;i++)
{
SListNode* newnode = BuySListNode(i);
if (phead == NULL)
{
ptail = phead = newnode;
}
else
{
ptail->next = newnode;
ptail = newnode;
}
}
return phead;
}
3.2.4 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
【算法步骤】
1.生成一个新节点,用指针newnode指向该节点。
2.需要判断头指针是否为空,分类处理,这里是允许头指针为空的,不需要停止程序,头指针为空说明链表为空。
3.头指针为空:指向将新节点的地址赋给头指针。
4.头指针不为空:定义一个指针cur从头指针开始向后遍历,找到链表的尾,将新节点插入到尾节点后面。
【算法实现】
void SListPushBack(SListNode** pplist, SLTDateType x)
{
SListNode* newnode = BuySListNode(x);
if (*pplist == NULL)
{
*pplist = newnode;
}
else
{
SListNode* cur = *pplist;
//找尾
while (cur->next)
{
cur = cur->next;
}
cur->next = newnode;
}
}
3.2.5 单链表的尾删
void SListPopBack(SListNode** pplist);
【算法步骤】
1.先判断头指针是否为空,为空则直接退出程序,此处头指针为空的情况不允许存在,因为头指针为空,说明链表为空,此时不能尾删。
2.但是我们需要判断一下链表是否只有一个节点,如果只有一个节点的话,直接将头指针释放,并且头指针置空。
3.如果链表不止一个节点,定义两个指针tail和指针prev,指针tail从头指针向后遍历找到链表的尾节点,指针prev则在指针tail向后遍历之前先记录一下指针tail指向的节点,方便我们进行尾删。
4.将指针tail释放,将prev的指针域置空。
【算法实现】
void SListPopBack(SListNode** pplist)
{
assert(*pplist);
if ((*pplist)->next == NULL)
{
free(*pplist);
pplist = NULL;
}
else
{
SListNode* tail = *pplist,*prev = *pplist;
while (tail->next)
{
prev = tail;
tail = tail->next;
}
free(tail);
prev->next = NULL;
}
}
3.2.6 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
【算法步骤】
1.此时我们不需要判断头节点是否为空,大家可以考虑一下为什么。
2.生成一个新的节点,用指针newnode指向新节点。
3.指针newnode的指针域指向头结点。
4.将指针newnode的地址赋给头指针。
【算法实现】
void SListPushFront(SListNode** pplist, SLTDateType x)
{
SListNode* newnode = BuySListNode(x);
newnode->next = *pplist;
*pplist = newnode;
}
3.2.7 单链表头删
void SListPopFront(SListNode** pplist);
【算法步骤】
1.首先我们需要判断一下头节点是否为空,为空则停止程序。
2.定义一个指针cur指向头结点的下一个节点。
3.将头结点释放。
4.将指针cur的地址赋给头指针。
【算法实现】
void SListPopFront(SListNode** pplist)
{
assert(*pplist);
SListNode* cur = (*pplist)->next;
free(*pplist);
*pplist = cur;
}
3.2.8 单链表查找
SListNode* SListFind(const SListNode* pplist, SLTDateType x);
【算法步骤】
1.判断头节点是否为空。为空则停止程序。
2.定义一个指针cur指向头结点。
3.判断指针cur的数据域是否等于x。
4.找到的话就返回该节点的地址,找到尾结点都找不到的话就返回NULL。
【算法实现】
SListNode* SListFind(const SListNode* plist, SLTDateType x)
{
assert(plist);
SListNode* cur = plist;
while (cur->next != NULL)
{
if (cur->data == x)
return cur;
else
cur = cur->next;
}
return NULL;
}
3.2.9 单链表在pos位置之后插入x节点
void SListInsertAfter(SListNode* pos, SLTDateType x);
【算法步骤】
1.判断指针pos是否为空。为空则停止程序。
2.生成一个新的节点,用指针tmp指向新节点。
3.新节点的指针域先指向pos结点的指针域,再将pos结点的指针域指向新节点。
大家可以考虑一下,可不可以将3的这两步的顺序调换一下,调换之后会发生什么。
大家还可以考虑一下,可不可以在pos位置之前插入x结点。
【算法实现】
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
assert(pos);
SListNode* tmp = BuySListNode(x);
tmp->next = pos->next;
pos->next = tmp;
}
3.2.10 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
【算法步骤】
1.判断pos结点和pos后面的节点是否为空。
2.定义一个指针cur指向pos节点的指针域。
3.将pos节点的指针域指向下一个节点的指针域。
4.再将指针cur指向的节点释放。
【算法实现】
void SListEraseAfter(SListNode* pos)
{
assert(pos);
assert(pos->next);
SListNode* cur = pos->next;
pos->next = pos->next->next;
free(cur);
}
3.2.11 单链表的销毁
void SListDestroy(SListNode* plist);
【算法步骤】
1.判断头结点是否为空,为空则停止程序。
2.定义一个指针指向头结点的指针域。
3.将头结点释放,再将指针cur的地址给头指针。
4.重复步骤2和步骤3。
【算法实现】
void SListDestroy(SListNode* plist)
{
assert(plist);
while (plist != NULL)
{
SListNode* cur = plist->next;
free(plist);
plist = cur;
}
}
3.3 单链表的原码
4.带头双向循环链表的实现
4.1 链表需要实现的接口
typedef int LTDataType;
typedef struct ListNode
{
struct ListNode* prev;
struct ListNode* next;
LTDataType data;
}LTNode;
//创建一个节点
LTNode* BuyLTNode(LTDataType x);
//双向链表初始化
LTNode* LTNodeInit();
// 双向链表打印
void LTNodePrint(LTNode* plist);
//双向链表的尾插
void LTNodePushBack(LTNode* plist, LTDataType x);
//双向链表的尾删
void LTNodePopBack(LTNode* plist);
//双向链表的头插
void LTNodePushFront(LTNode* plist, LTDataType x);
//双向链表的头删
void LTNodePopFront(LTNode* plist);
// 双向链表查找
LTNode* LTFind(LTNode* plist, LTDataType x);
// 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x);
// 双向链表删除pos位置的结点
void LTErase(LTNode* pos);
// 双向链表销毁
void LTDestory(LTNode* plist);
4.2 链表接口的具体实现
4.2.1 动态申请一个节点
LTNode* BuyLTNode(LTDataType x);
【算法步骤】
1.动态开辟一个新的节点,用指针newnode指向新生成的节点。
2.如果指针newnode为空,说明生成失败,程序停止。
3.将新节点的数据域赋值为x。
4.将新节点的prev指针和next指针都置空。
5.返回新节点的地址。
【算法实现】
LTNode* BuyLTNode(LTDataType x)
{
LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
if (!newnode)
{
perror("malloc fail\n");
exit(-1);
}
newnode->data = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
4.2.2 双向链表初始化
LTNode* LTNodeInit();
【算法步骤】
1.定义一个哨兵节点(头结点),数据域赋值为-1。
2.哨兵节点的前驱指针和后继指针都置空。
【算法实现】
LTNode* LTNodeInit()
{
LTNode* plist = BuyLTNode(-1);
plist->prev = plist;
plist->next = plist;
return plist;
}
4.2.3 双向链表打印
void LTNodePrint(LTNode* plist);
【算法步骤】
1.判断哨兵节点是否为空,为空则停止程序。
2.定义一个指针cur指向哨兵节点的下一个节点。
3.打印节点cur的数据域,将指针cur指向cur的下一个节点。
4.重复步骤3,直到指针cur为空。
【算法实现】
void LTNodePrint(LTNode* plist)
{
assert(plist);
LTNode* cur = plist->next;
while (cur != plist)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\n");
}
4.2.4 双向链表的尾插
void LTNodePushBack(LTNode* plist, LTDataType x);
【算法步骤】
1.判断哨兵节点是否为空,为空则停止程序。
2.生成一个新的节点,用指针newnode指向新节点。
3.定义一个指针tail指向哨兵节点的前驱节点,即为链表的尾结点。
4.将指针tail的后继指针指向新节点。将新节点的前驱指针指向tail节点。
5.将哨兵位的前驱指针指向新节点,将新节点的后继指针指向哨兵节点。
【算法实现】
void LTNodePushBack(LTNode* plist, LTDataType x)
{
assert(plist);
LTNode* newnode = BuyLTNode(x);
LTNode* tail = plist->prev;
tail->next = newnode;
newnode->prev = tail;
plist->prev = newnode;
newnode->next = plist;
}
4.2.5 双向链表的尾删
void LTNodePopBack(LTNode* plist);
【算法步骤】
1.断言哨兵节点和哨兵节点的后继节点不为空。为空则停止程序。
2.定义一个指针cur指向哨兵节点的前驱节点。
3.定义一个指针curprev指向cur节点的前驱节点。
4.将curprev节点的后继指针指向哨兵节点。
5.将哨兵节点的前驱指针指向cureprev节点。
【算法实现】
void LTNodePopBack(LTNode* plist)
{
assert(plist);
assert(plist->next != plist);
LTNode* cur = plist->prev;
LTNode* curprev = cur->prev;
curprev->next = plist;
plist->prev = curprev;
free(cur);
}
4.2.6 双向链表的头插
void LTNodePushFront(LTNode* plist, LTDataType x);
【算法步骤】
1.断言哨兵节点不为空,为空则停止程序。
2.生成一个新的节点,用指针newnode指向新节点。
3.定义一个指针指向哨兵节点的后继节点。
4.将哨兵节点的后继指针指向新节点,新节点的前驱指针指向哨兵节点。
5.将新节点的后继指针指向cur节点,cur节点的前驱指针指向新节点。
【算法实现】
void LTNodePushFront(LTNode* plist, LTDataType x)
{
assert(plist);
LTNode* newnode = BuyLTNode(x);
LTNode* cur = plist->next;
plist->next = newnode;
newnode->prev = plist;
newnode->next = cur;
cur->prev = newnode;
}
4.2.7 双向链表的头删
void LTNodePopFront(LTNode* plist);
【算法步骤】
1.断言哨兵节点和哨兵节点的后继节点不为空,为空则停止程序。
2.定义一个指针cur指向哨兵节点的后继节点。
3.定义一个指针curnext指向cur节点的后继节点。
4.将哨兵节点的后继指针域指向curnext节点,curnext节点的前驱指针域指向哨兵节点。
5.将cur节点释放。
【算法实现】
void LTNodePopFront(LTNode* plist)
{
assert(plist);
assert(plist->next != plist);
LTNode* cur = plist->next;
LTNode* curnext = cur->next;
plist->next = curnext;
curnext->prev = plist;
free(cur);
}
4.2.8 双向链表查找
LTNode* LTFind(LTNode* plist, LTDataType x);
【算法步骤】
1.断言哨兵节点不为空,为空则停止程序。
2.定义一个指针cur指向哨兵节点的后继节点。
3.如果cur的数据域等于x则返回该节点的地址。
4.如果找到哨兵节点还没有找到,就返回NULL。
【算法实现】
LTNode* LTFind(LTNode* plist, LTDataType x)
{
assert(plist);
LTNode* cur = plist->next;
while (cur != plist)
{
if (cur->data == x)
return cur;
cur = cur->next;
}
return NULL;
}
4.2.9 双向链表在pos的前面进行插入
void LTInsert(LTNode* pos, LTDataType x);
【算法步骤】
1.断言pos节点不为空,为空则停止程序。
2.生成一个新的节点,用指针newnode指向新节点。
3.定义一个指针cur指向pos节点的前驱节点。
4.将cur节点的后继指针指向新节点,新节点的前驱节点指向cur节点。
5.将pos节点的前驱指针指向新节点,新节点的后继指针指向pos节点。
【算法实现】
void LTInsert(LTNode* pos, LTDataType x)
{
assert(pos);
LTNode* newnode = BuyLTNode(x);
LTNode* cur = pos->prev;
cur->next = newnode;
newnode->prev = cur;
pos->prev = newnode;
newnode->next = pos;
}
4.2.10 双向链表删除pos位置的结点
void LTErase(LTNode* pos);
【算法步骤】
1.断言pos节点和pos节点不为空。
2.定义一个指针prev指向pos节点的前驱节点。
3.定义一个指针next指向pos节点的后继节点。
4.将prev节点的后继指针指向next节点。
5.将next节点的前驱指针指向prev节点。
6.释放pos节点。
【算法实现】
void LTErase(LTNode* pos)
{
assert(pos);
assert(pos->next != pos);
LTNode* prev = pos->prev;
LTNode* next = pos->next;
prev->next = next;
next->prev = prev;
free(pos);
}
4.2.11 双向链表销毁
void LTDestory(LTNode* plist);
【算法步骤】
1断言哨兵节点不为空。为空则停止程序。
2.定义一个指针cur指向哨兵节点的后继节点。
3.定义一个指针next指向cur节点的后继节点。
4.将cur节点释放,再将next节点的地址赋给指针cur。
5.重复步骤3和步骤4,直到指向哨兵节点。
6.将哨兵节点释放。
【算法实现】
void LTDestory(LTNode* plist)
{
assert(plist);
LTNode* cur = plist->next;
while (cur != plist)
{
LTNode* next = cur->next;
free(cur);
cur = next;
}
free(plist);
}
4.3 带头双向循环链表的原码
结语:
感谢大家看到这里,如有错误,希望各位大佬多多指正!
祝大家心情愉悦!