目录
1、链表的表示和实现
引言 继顺序表的问题:
问题:
1. 中间/头部的插入删除,时间复杂度为O(N)
2. 增容需要申请新空间,拷贝数据,释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长,势必会有一定的空间浪费。例如当前容量为100,满了以后增容到
200,我们再继续插入了5个数据,后面没有数据插入了,那么就浪费了95个数据空间。
解决以上问题 可引入链表
1.1链表的概念及结构
概念:链表是一种物理存储结构上非连续
、非顺序的存储结构,数据元素的
逻辑顺序
是通过链表
中的指针链接
次序实现的 。
![](https://i-blog.csdnimg.cn/blog_migrate/73b17dd9728bd8d3e91f72ef1d48b13f.png)
![](https://i-blog.csdnimg.cn/blog_migrate/e87ed1be2c38adf6ea1d7dcc2a4d339b.png)
链表是通过前一节点存着下一节点的地址,通过地址找到下一节点,从而达到逻辑上的连续。
实际中要实现的链表的结构非常多样,以下情况组合起来就有
8
种链表结构:
1.
单向、双向
2.
带头、不带头
3.
循环、非循环
最多可组合8种不同的链表
虽然有这么多的链表的结构,但是我们实际中最常用还是两种结构:
这两种中也包含了其余六种结构
结构最简单的无头不循环单向链表:
结构最复杂的带头循环双向链表:
1. 无头单向非循环链表:结构简单,一般不会单独用来存数据。实际中更多是作为其他数据结 构
的子结构,如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2.
带头双向循环链表:
结构最复杂
,一般用在单独存储数据。实际中使用的链表数据结构,都
是带头双向循环链表。另外这个结构虽然结构复杂,但是使用代码实现以后会发现结构会带
来很多优势,实现反而简单了,后面我们代码实现了就知道了。
1.2无头 不循环 单向 链表表篇
无头 不循环 单向链表的实现
typedef int SLTDataType;
typedef struct SlistNode
{
SLTDataType data;
struct SlistNode* next;
}SLTNode;
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* phead);
// 单链表尾插
void SListPushBack(SListNode** pphead, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pphead, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pphead);
// 单链表头删
void SListPopFront(SListNode** pphead);
// 单链表查找 pheadSListNode* SListFind(SListNode* pphead, SLTDateType x);
// 单链表在pos位置之前插入x
void SListInsert(SListNode** pphead, SListNode* pos, SLTDateType x);
// 单链表删除pos位置的值
void SListErase(SListNode** pphead, SListNode* pos);
以下分别写出接口函数
注意:单链表的插入和删除函数传参均需传二级指针
//尾插
void SlistPushBack(SLTNode**pphead, SLTDataType x)
{
SLTNode*newNode = (SLTNode*)malloc(sizeof(SLTNode));
newNode->data = x;
newNode->next = NULL;
if (*pphead == NULL)
{
*pphead = newNode;
}
else
{
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newNode;
}
}
//头插
void SlistPushFront(SLTNode** pphead, SLTDataType x)
{
SLTNode*newNode = (SLTNode*)malloc(sizeof(SLTNode));
newNode->next = *pphead;
newNode->data = x;
*pphead = newNode;
}
//尾删
void SlistPopBack(SLTNode** pphead)
{
if (*pphead == NULL)
{
return;
}
else if ((*pphead)->next==NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
SLTNode*prev = NULL;
SLTNode*tail = *pphead;
while (tail->next != NULL)
{
prev = tail;
tail = tail->next;
}
free(tail);
prev->next = NULL;
}
}
//头删
void SlistPophFront(SLTNode** pphead)
{
if (*pphead == NULL)
{
return;
}
else
{
SLTNode*start = *pphead;
*pphead = (*pphead)->next;
free(start);
start->next = NULL;
}
}
//查找
SLTNode* SlistFind(SLTNode*phead, SLTDataType x)
{
SLTNode*cur = phead;
while (cur != NULL)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
//任意pos位置的插入
void SlistInsert(SLTNode**pphead, SLTNode* pos, SLTDataType x)
{
if (*pphead == pos)
{
SlistPushFront(pphead, 10);
}
else
{
SLTNode*newnode = (SLTNode*)malloc(sizeof(SLTNode));
SLTNode*cur = *pphead;
while (cur->next != pos)
{
cur = cur->next;
}
newnode->data = x;
cur->next = newnode;
newnode->next = pos;
}
}
//任意pos位置的删除
void SlistErase(SLTNode**pphead, SLTNode* pos)
{
SLTNode*cur = *pphead;
while (cur->next != pos)
{
cur = cur->next;
}
cur->next = pos->next;
free(pos);
pos = NULL;
}
//打印
void SlistPrint(SLTNode* phead)
{
SLTNode* cur = phead;
while (cur != 0)
{
printf("%d->",cur->data);
cur = cur->next;
}
}
1.3带头 循环 双向链表篇
//带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}ListNode;
// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* phead);
// 双向链表打印
void ListPrint(ListNode* phead);
// 双向链表尾插
void ListPushBack(ListNode* phead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* phead);
// 双向链表头插
void ListPushFront(ListNode* phead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* phead);
// 双向链表查找
ListNode* ListFind(ListNode* phead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);
以下分别实现各个接口函数
注意:因为链表带头哨兵卫的头节点,函数传参时不需要改变外部plist,所以不需要传二级指针
//节点内存开辟
LSTNode* BuyListNode(LSTDataType x)
{
LSTNode*newnode = (LSTNode*)malloc(sizeof(LSTNode));
LSTDataType data= x;
LSTNode*prev = NULL;
LSTNode*next = NULL;
return newnode;
}
//初始化链表
LSTNode* ListInit()
{
LSTNode*phead = BuyListNode(1);
phead->next = phead;
phead->prev = phead;
return phead;
}
//打印
void ListPrint(LSTNode*phead)
{
LSTNode*cur = phead->next;
while (cur != phead)
{
printf("%d ", cur->data);
cur = cur->next;
}
printf("\n");
}
//内存销毁
void ListDestory(LSTNode*phead)
{
LSTNode*cur = phead->next;
while (cur != phead)
{
LSTNode*next = cur->next;
free(cur);
cur = next;
}
free(phead);
phead = NULL;
}
//尾插
void ListPushBack(LSTNode*phead, LSTDataType x)
{
// ListInsert(phead, phead, x); //也可以直接调用ListInsert接口函数实现
LSTNode*newnode = BuyListNode(x);
LSTNode*tail = phead->prev;
newnode->data = x;
tail->next = newnode;
newnode->prev = tail;
phead->prev = newnode;
newnode->next = phead;
}
//头插
void ListPushFront(LSTNode*phead, LSTDataType x)
{
//ListInsert(phead, phead->next, x); //也可直接调用ListInsert接口函数实现
LSTNode*newnode = BuyListNode(x);
LSTNode*first = phead->next;
newnode->data = x;
phead->next = newnode;
newnode->next = first;
first->prev = newnode;
newnode->prev = phead;
}
//尾删
void ListPopBack(LSTNode*phead)
{
assert(phead);
assert(phead->next != phead);
//ListErase(phead, phead->prev); //也可直接调用ListErase接口函数实现
LSTNode*tail = phead->prev;
tail->prev->next = phead;
phead->prev = tail->prev;
free(tail);
tail = NULL;
}
//头删
void ListPopFront(LSTNode*phead)
{
assert(phead);
assert(phead->next != phead);
//ListErase(phead,phead->next); //也可直接调用ListErase接口函数实现
LSTNode*first = phead->next;
LSTNode*second = first->next;
phead->next = second;
second->prev = phead;
free(first);
first = NULL;
}
//查找
LSTNode* ListNodeFind(LSTNode*phead, LSTDataType x)
{
LSTNode*cur = phead->next;
while(cur != phead)
{
if (cur->data == x)
{
//printf("找到了\n");
return cur;
}
cur = cur->next;
}
//printf("未找到!\n");
return 0; //未找到
}
//任意pos位置插入节点
void ListInsert(LSTNode*phead,LSTNode*pos, LSTDataType x)
{
LSTNode*newnode = BuyListNode(x);
newnode->data = x;
LSTNode*prev = pos->prev;
prev->next = newnode;
newnode->prev = prev;
newnode->next = pos;
pos->prev = newnode;
}
//任意pos位置删除节点
void ListErase(LSTNode*phead, LSTNode*pos)
{
LSTNode*prev = pos->prev;
LSTNode*next = pos->next;
prev->next =next;
next->prev = prev;
free(pos);
pos = NULL;
}
2.顺序表和链表的区别和联系
顺序表:
优点:
空间连续、支持随机访问
缺点:
1.
中间或前面部分的插入删除时间复杂度
O(N)
2. 2.
增容的代价比较大。
链表:
缺点:
以节点为单位存储,不支持随机访问
优点:
1.
任意位置插入删除时间复杂度为
O(1)
2.
没有增容消耗,按需申请节点空间,不用了直接释放。